returnn 1.20250122.134518__tar.gz → 1.20250122.223647__tar.gz

{returnn-1.20250122.134518/returnn.egg-info → returnn-1.20250122.223647}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: returnn
-Version: 1.20250122.134518
+Version: 1.20250122.223647
 Summary: The RWTH extensible training framework for universal recurrent neural networks
 Home-page: https://github.com/rwth-i6/returnn/
 Author: Albert Zeyer

returnn-1.20250122.223647/_setup_info_generated.py

@@ -0,0 +1,2 @@
+version = '1.20250122.223647'
+long_version = '1.20250122.223647+git.6dd961c'

{returnn-1.20250122.134518 → returnn-1.20250122.223647}/returnn/frontend/_cache.py

@@ -176,7 +176,7 @@ class DimWrapper:
             # We need some ref to the dyn size, and finalize this key when it goes out of scope.
             # This is only needed when there is no info on the static size (or eager scalar dyn size).
             ref(dim.dyn_size_ext.raw_tensor, finalize_callback)
-            if self.dim_value is None and dim.dyn_size_ext and dim.dyn_size_ext.raw_tensor is not None
+            if self.dim_value is None and dim.dyn_size_ext is not None and dim.dyn_size_ext.raw_tensor is not None
             else None
         )
         self._hash = hash(dim) if self.dim_value is None else hash(self.dim_value)
@@ -195,7 +195,7 @@ class DimWrapper:
 def _dim_value_for_key(dim: Dim) -> Optional[int]:
     if dim.size is not None:
         return dim.size
-    if dim.dyn_size_ext and not dim.dyn_size_ext.dims:
+    if dim.dyn_size_ext is not None and not dim.dyn_size_ext.dims:
         if dim.dyn_size_ext.raw_tensor is not None:
             # noinspection PyProtectedMember
             if dim.dyn_size_ext._raw_backend.executing_eagerly():

{returnn-1.20250122.134518 → returnn-1.20250122.223647}/returnn/frontend/_native/__init__.py

@@ -112,6 +112,8 @@ def setup():
     for name, cur_func in _TensorOpOverloadsMixin.__dict__.items():  # just all of them
         if not callable(cur_func):
             continue
+        if name in {"__bool__"}:  # some exceptions
+            continue
         assert name.startswith("__") and name.endswith("__")
         native_func = getattr(mod, "_tensor_" + name[2:-2] + "_instancemethod")
         assert callable(native_func)

{returnn-1.20250122.134518 → returnn-1.20250122.223647}/returnn/frontend/_random_journal.py

@@ -58,7 +58,7 @@ class RandomJournal:
         """read next"""
         assert self._cur_entry_idx < len(self._entries)
         entry = self._entries[self._cur_entry_idx]
-        if new_out_template:
+        if new_out_template is not None:
             assert new_out_template.dtype == entry.out.dtype, (
                 f"random journal entry dtype mismatch,"
                 f" expected {new_out_template}, got {entry.out} at index {self._cur_entry_idx}"

{returnn-1.20250122.134518 → returnn-1.20250122.223647}/returnn/frontend/conv.py

@@ -649,7 +649,7 @@ def make_conv_out_spatial_dims(
             assert isinstance(out_spatial_dim, Dim)
             if description_prefix and out_spatial_dim != in_spatial_dim:
                 out_spatial_dim.name = f"{description_prefix}:spatial{i}"
-            if in_spatial_dim.dyn_size_ext and out_spatial_dim.dyn_size_ext is None:
+            if in_spatial_dim.dyn_size_ext is not None and out_spatial_dim.dyn_size_ext is None:
                 out_spatial_dim.dyn_size_ext = _calc_out_dim(
                     in_dim=in_spatial_dim.dyn_size_ext,
                     filter_size=filter_size[i],

{returnn-1.20250122.134518 → returnn-1.20250122.223647}/returnn/frontend/dims.py

@@ -166,7 +166,7 @@ def num_elements_of_shape(
         for j, dim_ in enumerate(dims):
             if i == j:
                 continue
-            if dim_.dyn_size_ext and dim in dim_.dyn_size_ext.dims:
+            if dim_.dyn_size_ext is not None and dim in dim_.dyn_size_ext.dims:
                 related_dims.append(dim_)
         if not related_dims:
             if dim.is_static():

{returnn-1.20250122.134518 → returnn-1.20250122.223647}/returnn/frontend/rec.py

@@ -52,7 +52,7 @@ class LSTM(rf.Module):
         :return: output of shape {...,out_dim} if spatial_dim is single_step_dim else {...,spatial_dim,out_dim},
             and new state of the LSTM.
         """
-        if not state.h or not state.c:
+        if state.h is None or state.c is None:
             raise ValueError(f"{self}: state {state} needs attributes ``h`` (hidden) and ``c`` (cell).")
         if self.in_dim not in source.dims:
             raise ValueError(f"{self}: input {source} does not have in_dim {self.in_dim}")
@@ -188,7 +188,7 @@ class ZoneoutLSTM(LSTM):
         :return: output of shape {...,out_dim} if spatial_dim is single_step_dim else {...,spatial_dim,out_dim},
             and new state of the LSTM.
         """
-        if not state.h or not state.c:
+        if state.h is None or state.c is None:
             raise ValueError(f"{self}: state {state} needs attributes ``h`` (hidden) and ``c`` (cell).")
         if self.in_dim not in source.dims:
             raise ValueError(f"{self}: input {source} does not have in_dim {self.in_dim}")

{returnn-1.20250122.134518 → returnn-1.20250122.223647}/returnn/frontend/run_ctx.py

@@ -272,9 +272,9 @@ class RunCtx:
         assert dims is None or (
             isinstance(dims, (list, tuple)) and all(isinstance(dim, Dim) for dim in dims)
         ), f"dims should be a tuple of Dims, got {dims}"
-        if dims is None and expected_output:
+        if dims is None and expected_output is not None:
             dims = expected_output.dims
-        if dims is not None and expected_output:
+        if dims is not None and expected_output is not None:
             assert expected_output.dims == tuple(
                 dims
             ), f"mark_as_output: {name!r} dims mismatch from expected output, given {dims}, expected {expected_output}"
@@ -304,7 +304,7 @@ class RunCtx:
         assert name not in self.outputs.data
         self.outputs.data[name] = tensor
 
-        if expected_output:
+        if expected_output is not None:
             # Perform sanity checks using the expected output.
             # The expected output usually comes from `model_outputs` from the user config.
             # The dimensions of `expected_output` and `tensor` should match,
@@ -429,7 +429,7 @@ class Loss:
         """
         if self._mean_loss_cached is not None:
             return self._mean_loss_cached
-        if self.custom_inv_norm_factor:
+        if self.custom_inv_norm_factor is not None:
             loss = self.get_summed_loss()
             inv_norm = rf.reduce_sum(self.custom_inv_norm_factor, axis=self.custom_inv_norm_factor.dims)
             inv_norm = rf.cast(inv_norm, loss.dtype)
@@ -446,7 +446,7 @@ class Loss:
         """
         :return: inverse norm factor (scalar)
         """
-        if self.custom_inv_norm_factor:
+        if self.custom_inv_norm_factor is not None:
             if self.custom_inv_norm_factor.dims:
                 return rf.reduce_sum(self.custom_inv_norm_factor, axis=self.custom_inv_norm_factor.dims)
             return self.custom_inv_norm_factor
@@ -500,7 +500,7 @@ def _output_tensor_from_raw(raw_tensor, *, dims: Optional[Sequence[Dim]], name:
     assert isinstance(raw_tensor, _backend.global_backend.RawTensorType)
     tensor = rf.convert_to_tensor(raw_tensor, dims=dims)
     for axis, dim in enumerate(tensor.dims):
-        if dim.dyn_size_ext and dim.dyn_size_ext.raw_tensor is None:
+        if dim.dyn_size_ext is not None and dim.dyn_size_ext.raw_tensor is None:
             # Only non-scalar dyn sizes matter.
             if dim.dyn_size_ext.dims:
                 raise Exception(

{returnn-1.20250122.134518 → returnn-1.20250122.223647}/returnn/tensor/_dim_extra.py

@@ -94,7 +94,7 @@ class _DimExtra:
         if derived_from_op and not derived_from_op.output:
             derived_from_op.output = dim
         self.match_priority = match_priority
-        if src_data:
+        if src_data is not None:
             assert isinstance(src_data, _t.Tensor) and isinstance(src_axis, int)
         if not batch and dim.dyn_size_ext is not None:
             batch = dim.dyn_size_ext.batch
@@ -421,12 +421,12 @@ class _DimMixin:
 
         :param func: operates inplace
         """
-        dyn_size_ext = self.dyn_size_ext.copy() if self.dyn_size_ext else None
-        dyn_size_ext_max = self._dyn_size_max_value if self._dyn_size_max_value else None
+        dyn_size_ext = self.dyn_size_ext.copy() if self.dyn_size_ext is not None else None
+        dyn_size_ext_max = self._dyn_size_max_value if self._dyn_size_max_value is not None else None
         self.reset_raw(only_self=True)
-        if dyn_size_ext:
+        if dyn_size_ext is not None:
             func(dyn_size_ext)
-        if dyn_size_ext_max:
+        if dyn_size_ext_max is not None:
             func(dyn_size_ext_max)
         self.dyn_size_ext = dyn_size_ext
         self._dyn_size_max_value = dyn_size_ext_max
@@ -458,8 +458,8 @@ class _DimMixin:
         """
         :rtype: bool
         """
-        if (self.dyn_size_ext and not self.dyn_size_ext.is_valid_in_current_graph()) or (
-            self._dyn_size_max_value and not self._dyn_size_max_value.is_valid_in_current_graph()
+        if (self.dyn_size_ext is not None and not self.dyn_size_ext.is_valid_in_current_graph()) or (
+            self._dyn_size_max_value is not None and not self._dyn_size_max_value.is_valid_in_current_graph()
         ):  # maybe from an earlier run which reuses the dim tag
             # Reset and cleanup.
             self.reset_batch_ctx()
@@ -474,7 +474,7 @@ class _DimMixin:
         if not self._extra:
             return
         if not self.batch:
-            if self.dyn_size_ext and self.dyn_size_ext.batch:
+            if self.dyn_size_ext is not None and self.dyn_size_ext.batch:
                 self.batch = self.dyn_size_ext.batch
             else:
                 return
@@ -482,21 +482,21 @@ class _DimMixin:
         if not extra:
             return
         key = (self.batch, self.control_flow_ctx)
-        if self.dyn_size_ext and key not in extra.same_for_batch_ctx:
+        if self.dyn_size_ext is not None and key not in extra.same_for_batch_ctx:
             extra.same_for_batch_ctx[key] = self
         # Check if we can find more
         if key in extra.same_for_batch_ctx:
             same = extra.same_for_batch_ctx[key]
             if same is not self:
-                if same.dyn_size_ext and self.dyn_size_ext is None:
+                if same.dyn_size_ext is not None and self.dyn_size_ext is None:
                     self.dyn_size_ext = same.dyn_size_ext
-                if same.dyn_size_ext and same.dyn_size_ext.placeholder is not None:
+                if same.dyn_size_ext is not None and same.dyn_size_ext.placeholder is not None:
                     if self.dyn_size_ext.placeholder is None:
                         self.dyn_size_ext = same.dyn_size_ext
-                if self.dyn_size_ext and same.dyn_size_ext is None:
+                if self.dyn_size_ext is not None and same.dyn_size_ext is None:
                     same.dyn_size_ext = self.dyn_size_ext
-                if self.dyn_size_ext and self.dyn_size_ext.placeholder is not None:
-                    if not same.dyn_size_ext or same.dyn_size_ext.placeholder is None:
+                if self.dyn_size_ext is not None and self.dyn_size_ext.placeholder is not None:
+                    if same.dyn_size_ext is None or same.dyn_size_ext.placeholder is None:
                         same.dyn_size_ext = self.dyn_size_ext
                 # noinspection PyProtectedMember
                 if self._dyn_size_max_value is None and same._dyn_size_max_value is not None:
@@ -578,7 +578,7 @@ class _DimMixin:
                 else:
                     raise NotImplementedError("not yet implemented: multiple derived ctxs: %r" % (derived_ctxs,))
         if dim_tag:
-            assert not dim_tag.dyn_size_ext
+            assert dim_tag.dyn_size_ext is None
         dyn_size_ext = None
         # Maybe we have sth with the base batch without beam or padded batch which we can extend.
         if batch != batch.get_global_base():
@@ -614,7 +614,7 @@ class _DimMixin:
                             dyn_size_ext.placeholder, "_RETURNN_beam_expanded_base_data", None
                         )
                         if batch.beam:
-                            assert beam_expanded_base_data
+                            assert beam_expanded_base_data is not None
                         # Note: The beam expansion used tiling, which can be cached.
                         # This means that we could end up with the same size tensor (placeholder)
                         # for multiple different beams,
@@ -634,17 +634,17 @@ class _DimMixin:
                         if batch.beam:
                             dyn_size_ext.placeholder._RETURNN_dyn_size_beam = batch.beam
                             dyn_size_ext.placeholder._RETURNN_beam_expanded_base_data = beam_expanded_base_data
-        if not dyn_size_ext:
+        if dyn_size_ext is None:
             # Maybe we can infer dyn_size_ext, even with different batch.
             # Keep logic in sync with is_dim_known_in_batch_ctx.
             candidates = [self, same_base] + list(same_base_extra.same_for_batch_ctx.values())
             for other in candidates:
-                if other.dyn_size_ext and ControlFlowContext.is_parent_or_same(other.control_flow_ctx, ctx):
+                if other.dyn_size_ext is not None and ControlFlowContext.is_parent_or_same(other.control_flow_ctx, ctx):
                     dyn_size_ext = other.dyn_size_ext.copy_template()
                     dyn_size_ext.beam = batch.beam
                     dyn_size_ext.batch = batch
                     break
-        if dyn_size_ext:
+        if dyn_size_ext is not None:
             ctx = dyn_size_ext.control_flow_ctx
         elif dim_tag:
             ctx = dim_tag.control_flow_ctx
@@ -658,7 +658,7 @@ class _DimMixin:
                 # or it is defined for the same batch and ctx.
                 # In any case, reuse it then.
                 candidate.batch = batch
-                if dyn_size_ext:
+                if dyn_size_ext is not None:
                     if candidate.dyn_size_ext is not None:
                         candidate.dyn_size_ext.batch = batch
                         assert candidate.dyn_size_ext.dim_tags == dyn_size_ext.dim_tags
@@ -684,11 +684,11 @@ class _DimMixin:
                 dyn_size_ext=dyn_size_ext,
             )
             dim_tag.same_as = same_base
-        if dyn_size_ext and dyn_size_ext.placeholder is not None:
+        if dyn_size_ext is not None and dyn_size_ext.placeholder is not None:
             if _d.Dim.get_tag_from_size_tensor(dyn_size_ext.placeholder) is None:
                 dim_tag.set_tag_on_size_tensor(dyn_size_ext.placeholder, batch=batch)
         same_base_extra.same_for_batch_ctx[(batch, ctx)] = dim_tag
-        if dyn_size_ext:
+        if dyn_size_ext is not None:
             if dim_tag.dyn_size_ext is None:
                 dim_tag.dyn_size_ext = dyn_size_ext
             else:
@@ -709,7 +709,7 @@ class _DimMixin:
             self._extra.cache_dyn_size_ext_dev.clear()
         self.batch = None
         self.control_flow_ctx = None
-        if self.dyn_size_ext and self.dyn_size_ext.batch:
+        if self.dyn_size_ext is not None and self.dyn_size_ext.batch:
             self.dyn_size_ext = self.dyn_size_ext.copy_template()
             self.dyn_size_ext.batch = None
             self.dyn_size_ext.control_flow_ctx = None
@@ -771,7 +771,7 @@ class _DimMixin:
 
         :param tf.Tensor dyn_size:
         """
-        if self.dyn_size_ext and self.dyn_size_ext.placeholder is dyn_size:  # fast path check
+        if self.dyn_size_ext is not None and self.dyn_size_ext.placeholder is dyn_size:  # fast path check
             return
         assert self.can_be_used_as_dim()
         other = _d.Dim.get_tag_from_size_tensor(dyn_size)
@@ -787,7 +787,7 @@ class _DimMixin:
             return
         self._init_default_dyn_size_ext(dyn_size)
         self.set_tag_on_size_tensor(dyn_size)
-        assert self.dyn_size_ext.placeholder is dyn_size
+        assert self.dyn_size_ext is not None and self.dyn_size_ext.placeholder is dyn_size
 
     def _init_default_dyn_size_ext(self, dyn_size):
         """
@@ -814,7 +814,7 @@ class _DimMixin:
         """
         :return: dyn_size_ext on the device
         """
-        assert self.dyn_size_ext
+        assert self.dyn_size_ext is not None
         if not device or device == "cpu":
             return self.dyn_size_ext
 
@@ -837,7 +837,7 @@ class _DimMixin:
         """
         import returnn.frontend as rf
 
-        assert self.dyn_size_ext and self.dyn_size_ext.raw_tensor is not None
+        assert self.dyn_size_ext is not None and self.dyn_size_ext.raw_tensor is not None
         # noinspection PyProtectedMember
         backend = self.dyn_size_ext._raw_backend
 
@@ -914,7 +914,7 @@ class _DimMixin:
         """
         if self.is_batch_dim():
             return True
-        if not self.dyn_size_ext and self.dimension is not None:
+        if self.dyn_size_ext is None and self.dimension is not None:
             return True
         if self.dyn_size_ext is not None:
             return True
@@ -937,7 +937,7 @@ class _DimMixin:
             return True
         dim = self.get_for_batch_ctx(batch=batch, ctx=ctx, allow_none=True)
         if dim:
-            return bool(dim.dyn_size_ext)
+            return dim.dyn_size_ext is not None
         candidates = [self, self.get_same_base()]
         if self._extra:
             candidates += list(self._extra.same_for_batch_ctx.values())
@@ -953,7 +953,8 @@ class _DimMixin:
         :return: whether the dim is not static. usually means that it has seq lengths
         """
         return self.dimension is None and (
-            (self.dyn_size_ext and self.dyn_size_ext.dims) or (not self.dyn_size_ext and not self.is_batch_dim())
+            (self.dyn_size_ext is not None and self.dyn_size_ext.dims)
+            or (self.dyn_size_ext is None and not self.is_batch_dim())
         )
 
     def is_dynamic(self) -> bool:
@@ -997,7 +998,7 @@ class _DimMixin:
         :return: whether this dim tag for this specific batch (incl beam) is the same as the given size
         :rtype: bool
         """
-        if self.dyn_size_ext and x is self.dyn_size_ext.placeholder:
+        if self.dyn_size_ext is not None and x is self.dyn_size_ext.placeholder:
             return True
         tag = _DimMixin.get_tag_from_size_tensor(x)
         if tag and tag == self:
@@ -1084,7 +1085,7 @@ class _DimMixin:
             self.batch = batch  # overtake
         if not self.is_batch_dim() and self.is_dynamic():
             if same_as_before:
-                assert self.dyn_size_ext and self.dyn_size_ext.placeholder is not None
+                assert self.dyn_size_ext is not None and self.dyn_size_ext.placeholder is not None
                 # Do not overwrite it.
             else:
                 self._init_default_dyn_size_ext(x)
@@ -1109,7 +1110,7 @@ class _DimMixin:
         if self.is_static():
             return
         self._validate_in_current_graph()
-        if self.dyn_size_ext and (self.dyn_size_ext.placeholder is not None or template_only):
+        if self.dyn_size_ext is not None and (self.dyn_size_ext.placeholder is not None or template_only):
             return
         same_base = self.get_same_base()
         op = self.derived_from_op or same_base.derived_from_op
@@ -1126,7 +1127,7 @@ class _DimMixin:
             for x_dim in op.inputs:
                 if self.batch:
                     x_dim = x_dim.get_for_batch_ctx(self.batch, self.control_flow_ctx)
-                if x_dim.dyn_size_ext and x_dim.dyn_size_ext.raw_tensor is not None:
+                if x_dim.dyn_size_ext is not None and x_dim.dyn_size_ext.raw_tensor is not None:
                     # noinspection PyProtectedMember
                     backend = x_dim.dyn_size_ext._raw_backend
                     break
@@ -1274,12 +1275,12 @@ class _DimMixin:
             if self.batch:
                 x_dim = x_dim.get_for_batch_ctx(self.batch, self.control_flow_ctx)
             x_dim.complete_dyn_size(template_only=template_only, _backend=backend)
-            if not x_dim.dyn_size_ext and not x_dim.dimension:
+            if x_dim.dyn_size_ext is None and not x_dim.dimension:
                 return
             y = _bin_op(y, x_dim.dimension or x_dim.dyn_size_ext)
             if not template_only and y.raw_tensor is not None:
                 y_max_value = _bin_op(y_max_value, x_dim.get_dim_value_tensor())
-        assert y, f"op {op}?"
+        assert y is not None, f"op {op}?"
         if self.dyn_size_ext is not None:
             assert self.dyn_size_ext.dim_tags == y.dim_tags
         if y.batch:
@@ -1288,8 +1289,8 @@ class _DimMixin:
             else:
                 self.batch = y.batch
         self.dyn_size_ext = y
-        if not template_only and y_max_value:
-            assert y_max_value and y_max_value.raw_tensor is not None
+        if not template_only and y_max_value is not None:
+            assert y_max_value is not None and y_max_value.raw_tensor is not None
             self._dyn_size_max_value = y_max_value
         if tf and y.placeholder is not None:
             self.set_tag_on_size_tensor(y.placeholder)
@@ -1695,7 +1696,9 @@ class _DimMixin:
             assert isinstance(self._extra.src_axis, int)
             # Maybe it changed in the meanwhile, so check.
             tag = self._extra.src_data.get_dim_tag(self._extra.src_axis)
-            if tag.description == self.description and (not tag.dyn_size_ext or not tag._validate_in_current_graph()):
+            if tag.description == self.description and (
+                tag.dyn_size_ext is None or not tag._validate_in_current_graph()
+            ):
                 tag.dyn_size_ext = self.get_dyn_size_ext_for_batch_ctx(
                     tag.batch, tag.control_flow_ctx, template_only=True
                 )
@@ -1709,7 +1712,7 @@ class _DimMixin:
                     other_same_base.batch, other_same_base.control_flow_ctx, template_only=True
                 )
                 other_same_base._maybe_update()
-        if not self.dyn_size_ext or not self._validate_in_current_graph():
+        if self.dyn_size_ext is None or not self._validate_in_current_graph():
             self.dyn_size_ext = other_same_base.get_dyn_size_ext_for_batch_ctx(
                 self.batch, self.control_flow_ctx, template_only=True
             )
@@ -1720,7 +1723,7 @@ class _DimMixin:
             )
             other_same_base._maybe_update()
         if (
-            self.dyn_size_ext
+            self.dyn_size_ext is not None
             and self.dyn_size_ext.raw_tensor is None
             and other_same_base.dyn_size_ext.raw_tensor is not None
         ):
@@ -1792,7 +1795,7 @@ class _DimMixin:
                 if not dim._validate_in_current_graph():
                     continue
                 self_dim = self._make_extra().same_for_batch_ctx.get(key, None)
-                if self_dim and (self_dim.dyn_size_ext or not dim.dyn_size_ext):
+                if self_dim and (self_dim.dyn_size_ext is not None or dim.dyn_size_ext is None):
                     continue  # keep ours
                 if dim.dyn_size_ext is None:
                     continue  # undefined, do not overtake
@@ -1982,7 +1985,7 @@ class _DimMixin:
         self.complete_dyn_size()
         if self._dyn_size_max_value is not None:
             return self._dyn_size_max_value
-        if self.dyn_size_ext and self.dyn_size_ext.placeholder is not None:
+        if self.dyn_size_ext is not None and self.dyn_size_ext.placeholder is not None:
             if self.dyn_size_ext.batch_ndim > 0:
                 res = rf.reduce_max(
                     self.dyn_size_ext,

{returnn-1.20250122.134518 → returnn-1.20250122.223647}/returnn/tensor/_tensor_extra.py

@@ -330,7 +330,7 @@ class _TensorMixin(_TensorMixinBase):
                 if tag.is_batch_dim():
                     continue
                 if tag.is_dynamic():
-                    assert tag.dyn_size_ext, "%s sanity_check: dynamic dim %s undefined" % (self, tag)
+                    assert tag.dyn_size_ext is not None, "%s sanity_check: dynamic dim %s undefined" % (self, tag)
                     if not ignore_placeholder:
                         if tag.dyn_size_ext.placeholder is None:
                             tag.complete_dyn_size()
@@ -2519,7 +2519,7 @@ class _TensorMixin(_TensorMixinBase):
         dim_tag = self.dim_tags[axis]
         # It's possible that dim tags are not unique (https://github.com/rwth-i6/returnn/issues/632).
         matching_tags = [i for (i, tag) in enumerate(self.dim_tags) if tag == dim_tag]
-        if dim_tag.dyn_size_ext and len(matching_tags) == 1:
+        if dim_tag.dyn_size_ext is not None and len(matching_tags) == 1:
             return dim_tag
         if axis == self.time_dim_axis:
             return "T"  # this might change
@@ -2800,7 +2800,7 @@ class _TensorMixin(_TensorMixinBase):
         assert self.batch_dim_axis is not None
         batch_dim_ = self._dims[self.batch_dim_axis]
         assert isinstance(batch_dim_, Dim)
-        if batch_dim_.dyn_size_ext and batch_dim_.dyn_size_ext.raw_tensor is not None:
+        if batch_dim_.dyn_size_ext is not None and batch_dim_.dyn_size_ext.raw_tensor is not None:
             backend = batch_dim_.dyn_size_ext._raw_backend
             return backend.fill_raw([batch_dim_.dyn_size_ext.raw_tensor], dim.size)
         import tensorflow as tf
@@ -2847,7 +2847,7 @@ class _TensorMixin(_TensorMixinBase):
         assert 0 <= axis < self.batch_ndim
         assert axis != self.batch_dim_axis
         tag: Dim = self.dim_tags[axis]
-        assert tag.dyn_size_ext and tag.dyn_size_ext.raw_tensor is not None
+        assert tag.dyn_size_ext is not None and tag.dyn_size_ext.raw_tensor is not None
         backend = tag.dyn_size_ext._raw_backend
         assert set(tag.dyn_size_ext.dim_tags).issubset(self.dim_tags)  # https://github.com/rwth-i6/returnn/issues/721
         with backend.name_scope_raw("get_sequence_mask_broadcast"):
@@ -2900,7 +2900,7 @@ class _TensorMixin(_TensorMixinBase):
         assert 0 <= axis < self.batch_ndim
         assert axis != self.batch_dim_axis
         tag = self.dim_tags[axis]
-        assert tag.dyn_size_ext
+        assert tag.dyn_size_ext is not None
         return tag.dyn_size_ext.copy_compatible_to(self, check_dtype=False, check_sparse=False).placeholder
 
     def num_elements(self: Tensor) -> Union[int, Tensor]:

{returnn-1.20250122.134518 → returnn-1.20250122.223647}/returnn/tensor/_tensor_op_overloads.py

@@ -17,6 +17,16 @@ class _TensorOpOverloadsMixin(_TensorMixinBase):
     # Note that all those ops have native implementations as well,
     # so keep the logic in sync.
 
+    def __bool__(self):
+        from returnn.log import log
+        from returnn.util.basic import BehaviorVersion
+
+        if BehaviorVersion.get() >= 22:
+            raise TypeError(f"{self} __bool__: Using a Tensor in a boolean context is not allowed.")
+        log.print_deprecation_warning(
+            f"{self} __bool__: Using a Tensor in a boolean context is deprecated.", behavior_version=22
+        )
+
     # --- comparisons
 
     def __eq__(self: Tensor, other: Union[_rf_types.RawTensorTypes, Tensor]) -> Union[Tensor, bool]:

{returnn-1.20250122.134518 → returnn-1.20250122.223647}/returnn/tensor/dim.py

@@ -70,7 +70,7 @@ class Dim(_DimMixin):
         if dimension is None:
             self.capacity = capacity
             self.size = None
-            self.dyn_size_ext = dyn_size_ext.copy() if dyn_size_ext else None
+            self.dyn_size_ext = dyn_size_ext.copy() if dyn_size_ext is not None else None
         elif isinstance(dimension, int):
             self.capacity = capacity or dimension
             self.size = dimension

{returnn-1.20250122.134518 → returnn-1.20250122.223647}/returnn/tensor/tensor_dict.py

@@ -100,7 +100,7 @@ class TensorDict:
                     continue
                 key_ = f"{key}:size{i}"
                 assert key_ not in out
-                if dim.is_batch_dim() and (not dim.dyn_size_ext or dim.dyn_size_ext.raw_tensor is None):
+                if dim.is_batch_dim() and (dim.dyn_size_ext is None or dim.dyn_size_ext.raw_tensor is None):
                     if include_scalar_dyn_sizes:
                         dim_value = dim.get_dim_value()
                         assert isinstance(

{returnn-1.20250122.134518 → returnn-1.20250122.223647}/returnn/tf/frontend_layers/_backend.py

@@ -63,7 +63,7 @@ class ReturnnLayersBackend(Backend[Layer]):
         usages: List[Tensor] = []
         visited = set()
         for use in x.raw_tensor.usages:
-            if not use.tensor or use.tensor in visited:
+            if use.tensor is None or use.tensor in visited:
                 continue
             visited.add(use.tensor)
             usages.append(use.tensor)
@@ -878,7 +878,7 @@ class ReturnnLayersBackend(Backend[Layer]):
             out = rfl.make_layer(
                 {
                     "class": "eval",
-                    "from": [recent] if recent else [],  # use as control dependency
+                    "from": [recent] if recent is not None else [],  # use as control dependency
                     "eval": _random_replay_eval,
                     "eval_locals": {"idx": ReturnnLayersBackend._random_journal.get_graph_reader_idx()},
                     "out_type": {"dims": dims, "dtype": dtype, "sparse_dim": sparse_dim, "feature_dim": feature_dim},

{returnn-1.20250122.134518 → returnn-1.20250122.223647}/returnn/tf/frontend_layers/dims.py

@@ -67,7 +67,7 @@ def _register_dim_deps_when_novel(dim: Dim, deps: List[Tensor]):
             return  # discard new list, keep old
     if _register_dim_via_dyn_layer(dim):
         return
-    if dim.dyn_size_ext and not isinstance(dim.dyn_size_ext.raw_tensor, rfl.Layer):
+    if dim.dyn_size_ext is not None and not isinstance(dim.dyn_size_ext.raw_tensor, rfl.Layer):
         # In the TF net dict backend, the dims dyn_size_ext are usually just templates.
         # The raw_tensor would not be set.
         # Once the net dict is created, and then only when the actual TFNetwork is created,
@@ -110,7 +110,7 @@ def _register_dim_via_dyn_layer(dim: Dim) -> bool:
         return False
     if dim in _dim_deps:
         return False
-    assert dim.dyn_size_ext
+    assert dim.dyn_size_ext is not None
     if dim.dyn_size_ext.raw_tensor is None:
         return False
     assert isinstance(dim.dyn_size_ext.raw_tensor, rfl.Layer)

{returnn-1.20250122.134518 → returnn-1.20250122.223647}/returnn/tf/frontend_layers/layer.py

@@ -180,7 +180,7 @@ class Layer:
 
     def __repr__(self):
         parts = [self.get_abs_name_repr()]
-        if self.tensor:
+        if self.tensor is not None:
             parts.append("[%s]" % ",".join(self.tensor.get_batch_axes_short_description()))
         return f"<{self.__class__.__name__} {' '.join(parts)}>"
 
@@ -634,7 +634,7 @@ class Layer:
         Creates the child together with a layer ref if it does not exist yet.
         """
         child = self.get_child(name)
-        if not child.tensor:
+        if child.tensor is None:
             child.tensor = data
         assert child.tensor is data
         if data.raw_tensor is None:
@@ -718,7 +718,11 @@ class Layer:
             # However, we allow to use the name if it is the attrib itself.
             if self.module and name not in reserved_names and getattr(self.parent.module, name, None) is self.module:
                 return name
-            if self.tensor and name not in reserved_names and getattr(self.parent.module, name, None) is self.tensor:
+            if (
+                self.tensor is not None
+                and name not in reserved_names
+                and getattr(self.parent.module, name, None) is self.tensor
+            ):
                 return name
             # We might exclude all other attribs.
             # However, e.g. "dropout" is a common attrib storing the dropout rate (float),
@@ -761,7 +765,7 @@ class Layer:
             nest.map_structure(_maybe_add_dep, self.layer_dict)
         if self.children and "output" in self.children:
             _maybe_add_dep(self.children["output"].tensor)
-        if self.parent and self.parent.tensor:
+        if self.parent and self.parent.tensor is not None:
             _maybe_add_dep(self.parent.tensor)
         if self.layer_extra_dependencies:
             dep_list.extend(self.layer_extra_dependencies)
@@ -1101,7 +1105,7 @@ class _NetDictBuilderCtx:
                 if dim.dyn_size_ext is None:
                     dim.complete_dyn_size()
                 assert (
-                    dim.dyn_size_ext
+                    dim.dyn_size_ext is not None
                 ), f"{sub_name_ctx}: need {dim} to be defined to be able to know about implicit dims"
             dim_tags.extend(data_template.dim_tags_set_implicit_only_wrapped)
             assert len(dim_tags) == len(

{returnn-1.20250122.134518 → returnn-1.20250122.223647}/returnn/tf/frontend_layers/loop.py

@@ -539,8 +539,8 @@ class _LoopState:
 
     def _map_name_ctx_to_last_tensor(self, name_ctx: rfl.Layer) -> Tensor:
         assert isinstance(name_ctx, rfl.Layer)
-        assert name_ctx.tensor, f"{self.loop} state {name_ctx} not assigned?"
-        assert self.loop.name_ctx.tensor, f"{self.loop} not yet exited?"
+        assert name_ctx.tensor is not None, f"{self.loop} state {name_ctx} not assigned?"
+        assert self.loop.name_ctx.tensor is not None, f"{self.loop} not yet exited?"
         return self.loop.last(name_ctx.tensor)
 
     def get_last(self):

{returnn-1.20250122.134518 → returnn-1.20250122.223647}/returnn/tf/frontend_layers/make_layer.py

@@ -313,7 +313,7 @@ def register_extern_data(data: Tensor[rfl.Layer]):
                 dtype=data.size_dtype,
                 batch=data.batch,
             )
-        if tag.is_batch_dim() and not tag.dyn_size_ext and tag.dimension is None:
+        if tag.is_batch_dim() and tag.dyn_size_ext is None and tag.dimension is None:
             # Undefined batch dim tag. Set default data template.
             batch_dim.dyn_size_ext = orig_tag.dyn_size_ext = tag.dyn_size_ext = Tensor(
                 name=f"batch_dim_default_dyn_size_ext",

{returnn-1.20250122.134518 → returnn-1.20250122.223647}/returnn/tf/frontend_layers/prev_tensor_ref.py

@@ -22,7 +22,7 @@ class PrevTensorRef(Tensor):
         """
         parent_name_ctx = cur_layer_name_ctx.parent
         prev_tensor_name_ctx = parent_name_ctx.get_child(f"prev:{cur_layer_name_ctx.name}")
-        if prev_tensor_name_ctx.tensor:
+        if prev_tensor_name_ctx.tensor is not None:
             prev_tensor_ref = prev_tensor_name_ctx.tensor
             assert isinstance(prev_tensor_ref, PrevTensorRef)
             assert prev_tensor_ref.cur_layer_name_ctx is cur_layer_name_ctx