returnn 1.20250122.105051__tar.gz → 1.20250122.134518__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: returnn
-Version: 1.20250122.105051
+Version: 1.20250122.134518
 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.134518/_setup_info_generated.py

@@ -0,0 +1,2 @@
+version = '1.20250122.134518'
+long_version = '1.20250122.134518+git.5b30b33'

{returnn-1.20250122.105051 → returnn-1.20250122.134518}/returnn/frontend/_numpy_backend.py

@@ -166,7 +166,7 @@ class NumpyBackend(Backend[numpy.ndarray]):
         :param device:
         :return: tensor with shape [dim]
         """
-        if not dtype and dim.dyn_size_ext:
+        if not dtype and dim.dyn_size_ext is not None:
             dtype = dim.dyn_size_ext.dtype
         if not dtype:
             dtype = rf.get_default_array_index_dtype()

{returnn-1.20250122.105051 → returnn-1.20250122.134518}/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 not out_spatial_dim.dyn_size_ext:
+            if in_spatial_dim.dyn_size_ext 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.105051 → returnn-1.20250122.134518}/returnn/frontend/dims.py

@@ -30,7 +30,7 @@ def range_over_dim(dim: Dim, *, dtype: Optional[str] = None, device: Optional[st
     :param device,
     :return: tensor with shape [dim]
     """
-    if dim.dyn_size_ext:
+    if dim.dyn_size_ext is not None:
         backend = get_backend_by_tensor(dim.dyn_size_ext, fallback=global_backend)
     else:
         backend = global_backend

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

@@ -96,7 +96,7 @@ class _DimExtra:
         self.match_priority = match_priority
         if src_data:
             assert isinstance(src_data, _t.Tensor) and isinstance(src_axis, int)
-        if not batch and dim.dyn_size_ext:
+        if not batch and dim.dyn_size_ext is not None:
             batch = dim.dyn_size_ext.batch
             if not control_flow_ctx:
                 control_flow_ctx = dim.dyn_size_ext.control_flow_ctx
@@ -197,7 +197,7 @@ class _DimMixin:
         :return: batch info (deprecated)
         """
         if not self._extra:
-            if self.dyn_size_ext:
+            if self.dyn_size_ext is not None:
                 return self.dyn_size_ext.batch
             return None
         return self._extra.batch
@@ -214,7 +214,7 @@ class _DimMixin:
         :return: control flow context (deprecated)
         """
         if not self._extra:
-            if self.dyn_size_ext:
+            if self.dyn_size_ext is not None:
                 return self.dyn_size_ext.control_flow_ctx
             return None
         return self._extra.control_flow_ctx
@@ -291,7 +291,7 @@ class _DimMixin:
         elif self.dimension is not None:
             desc += f"({self.dimension})"
         else:
-            if self.dyn_size_ext:
+            if self.dyn_size_ext is not None:
                 desc += "[%s]" % ",".join(self.dyn_size_ext.get_batch_axes_short_description(special_axes=False))
             else:
                 desc += "[?]"
@@ -383,7 +383,7 @@ class _DimMixin:
             visited.add(id(dim))
             dim.reset_batch_ctx()
             dim._dyn_size_max_value = None
-            if dim.dyn_size_ext:
+            if dim.dyn_size_ext is not None:
                 dim.dyn_size_ext.reset()
             # noinspection PyProtectedMember
             dim_extra = dim._extra
@@ -446,7 +446,7 @@ class _DimMixin:
         # E.g. ctx == loop(time_dim), when self.control_flow_ctx == None,
         # we can use self in ctx, iff time_dim not in self.dyn_size_ext.dim_tags.
         # We can only do this check if we know about dyn_size_ext.
-        if not self.dyn_size_ext:
+        if self.dyn_size_ext is None:
             return False
         parent_dims = ControlFlowContext.collect_parent_dims(ctx)
         for dim in self.dyn_size_ext.dim_tags:
@@ -488,12 +488,12 @@ class _DimMixin:
         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 not self.dyn_size_ext:
+                if same.dyn_size_ext 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 self.dyn_size_ext.placeholder is None:
                         self.dyn_size_ext = same.dyn_size_ext
-                if self.dyn_size_ext and not same.dyn_size_ext:
+                if self.dyn_size_ext 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:
@@ -521,10 +521,10 @@ class _DimMixin:
         from returnn.tensor import ControlFlowContext
 
         assert self.can_be_used_as_dim()
-        if self.batch == batch and self._can_use_in_ctx(ctx) and self.dyn_size_ext:
+        if self.batch == batch and self._can_use_in_ctx(ctx) and self.dyn_size_ext is not None:
             self._validate_in_current_graph()
             self._maybe_update()
-            if self.batch == batch and self._can_use_in_ctx(ctx) and self.dyn_size_ext:  # check again
+            if self.batch == batch and self._can_use_in_ctx(ctx) and self.dyn_size_ext is not None:  # check again
                 return self
         if self.is_batch_dim():
             # We ignore the ctx for the batch dim currently.
@@ -550,11 +550,11 @@ class _DimMixin:
                         assert (
                             tag.batch == batch
                         )  # some code updated batch directly (incorrectly) and could trigger this
-                        if tag.dyn_size_ext:
+                        if tag.dyn_size_ext is not None:
                             return tag
                         dim_tag = tag
                         break
-            if same_base.batch == batch and same_base._can_use_in_ctx(ctx) and same_base.dyn_size_ext:
+            if same_base.batch == batch and same_base._can_use_in_ctx(ctx) and same_base.dyn_size_ext is not None:
                 return same_base
         else:
             same_base = self
@@ -585,7 +585,7 @@ class _DimMixin:
             batch_base = batch.get_global_base()
             base_can_use_in_ctx = None  # type: Optional[_d.Dim]
             # noinspection PyProtectedMember
-            if same_base.batch == batch_base and same_base._can_use_in_ctx(ctx) and same_base.dyn_size_ext:
+            if same_base.batch == batch_base and same_base._can_use_in_ctx(ctx) and same_base.dyn_size_ext is not None:
                 base_can_use_in_ctx = same_base
             elif same_base._extra:
                 from returnn.tf.util.data import ControlFlowContext
@@ -593,10 +593,15 @@ class _DimMixin:
                 for ctx_ in ControlFlowContext.abs_ctx_stack_with_root(ctx):
                     # noinspection PyProtectedMember
                     tag = same_base._extra.same_for_batch_ctx.get((batch_base, ctx_), None)
-                    if tag and tag._can_use_in_ctx(ctx) and tag._validate_in_current_graph() and tag.dyn_size_ext:
+                    if (
+                        tag
+                        and tag._can_use_in_ctx(ctx)
+                        and tag._validate_in_current_graph()
+                        and tag.dyn_size_ext is not None
+                    ):
                         base_can_use_in_ctx = tag
                         break
-            if base_can_use_in_ctx and base_can_use_in_ctx.dyn_size_ext:
+            if base_can_use_in_ctx and base_can_use_in_ctx.dyn_size_ext is not None:
                 if base_can_use_in_ctx.dyn_size_ext.have_batch_axis():
                     # The same_base has some dyn size without any beam nor control flow context.
                     # We can expand it to the current beam, or extend by padded batch.
@@ -654,13 +659,13 @@ class _DimMixin:
                 # In any case, reuse it then.
                 candidate.batch = batch
                 if dyn_size_ext:
-                    if candidate.dyn_size_ext:
+                    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
                     else:
                         candidate.dyn_size_ext = dyn_size_ext
                     assert not candidate.dyn_size_ext.control_flow_ctx
-                elif candidate.dyn_size_ext:
+                elif candidate.dyn_size_ext is not None:
                     candidate.dyn_size_ext.batch = batch
                 else:
                     candidate.complete_dyn_size(template_only=True)
@@ -684,11 +689,11 @@ class _DimMixin:
                 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 not dim_tag.dyn_size_ext:
+            if dim_tag.dyn_size_ext is None:
                 dim_tag.dyn_size_ext = dyn_size_ext
             else:
                 assert dim_tag.dyn_size_ext.dims == dyn_size_ext.dims
-        elif dim_tag.dyn_size_ext:
+        elif dim_tag.dyn_size_ext is not None:
             pass
         else:
             dim_tag.complete_dyn_size(template_only=True)
@@ -719,7 +724,7 @@ class _DimMixin:
         assert self.can_be_used_as_dim()
         same = self.get_for_batch_ctx(batch, ctx)
         assert dyn_size_ext.batch == batch and dyn_size_ext.control_flow_ctx == ctx
-        if same.dyn_size_ext:
+        if same.dyn_size_ext is not None:
             assert same.dyn_size_ext.dim_tags == dyn_size_ext.dim_tags
             if dyn_size_ext.placeholder is not None:
                 same.dyn_size_ext.placeholder = dyn_size_ext.placeholder
@@ -755,7 +760,7 @@ class _DimMixin:
           If the dyn size can potentially be of a different shape, directly access dyn_size_ext.
         :rtype: tf.Tensor|None
         """
-        if self.dyn_size_ext:
+        if self.dyn_size_ext is not None:
             return self.dyn_size_ext.placeholder
         return None
 
@@ -788,7 +793,7 @@ class _DimMixin:
         """
         :param tf.Tensor dyn_size:
         """
-        if self.dyn_size_ext:
+        if self.dyn_size_ext is not None:
             if self.dyn_size_ext.placeholder is not None:
                 # Do not allow resetting it to sth different.
                 assert self.dyn_size_ext.placeholder is dyn_size
@@ -911,12 +916,12 @@ class _DimMixin:
             return True
         if not self.dyn_size_ext and self.dimension is not None:
             return True
-        if self.dyn_size_ext:
+        if self.dyn_size_ext is not None:
             return True
         extra = self._get_same_base_extra()
         if extra:
             for _, other in extra.same_for_batch_ctx.items():
-                if other.dyn_size_ext:
+                if other.dyn_size_ext is not None:
                     return True
         return False
 
@@ -939,7 +944,7 @@ class _DimMixin:
         for dim in candidates:
             # By intention, ignore the batch, only check the ctx.
             # Keep logic in sync with get_for_batch_ctx.
-            if ControlFlowContext.is_parent_or_same(dim.control_flow_ctx, ctx) and dim.dyn_size_ext:
+            if ControlFlowContext.is_parent_or_same(dim.control_flow_ctx, ctx) and dim.dyn_size_ext is not None:
                 return True
         return False
 
@@ -973,7 +978,7 @@ class _DimMixin:
             return False
         if self.capacity is not None:
             return True
-        if not self.dyn_size_ext:  # unknown, so we can only guess
+        if self.dyn_size_ext is None:  # unknown, so we can only guess
             if self.is_batch_dim():
                 return False
             return True
@@ -1130,7 +1135,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:
+            if x_dim.dyn_size_ext is not None:
                 size_dtype = x_dim.dyn_size_ext.dtype
                 break
         if not size_dtype:
@@ -1275,7 +1280,7 @@ class _DimMixin:
             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}?"
-        if self.dyn_size_ext:
+        if self.dyn_size_ext is not None:
             assert self.dyn_size_ext.dim_tags == y.dim_tags
         if y.batch:
             if self.batch:
@@ -1789,7 +1794,7 @@ class _DimMixin:
                 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):
                     continue  # keep ours
-                if not dim.dyn_size_ext:
+                if dim.dyn_size_ext is None:
                     continue  # undefined, do not overtake
                 self._extra.same_for_batch_ctx[key] = dim
             # noinspection PyProtectedMember
@@ -1815,8 +1820,8 @@ class _DimMixin:
                 key = base.batch, base.control_flow_ctx
                 assert key not in self_base_extra.same_for_batch_ctx
                 self_base_extra.same_for_batch_ctx[key] = self
-            if not self.dyn_size_ext:
-                if base.dyn_size_ext:
+            if self.dyn_size_ext is None:
+                if base.dyn_size_ext is not None:
                     if base.batch and base.batch == self.batch and base.control_flow_ctx == self.control_flow_ctx:
                         self.dyn_size_ext = base.dyn_size_ext.copy_template(name="%s:size" % self_base.description)
                 elif base.is_batch_dim():
@@ -1914,7 +1919,7 @@ class _DimMixin:
         :return: size tensor, or dyn_size_ext if defined
         :rtype: _t.Tensor
         """
-        if self.dyn_size_ext:
+        if self.dyn_size_ext is not None:
             if not device or device == "cpu":
                 return self.dyn_size_ext
             return self.get_dyn_size_ext_for_device(device)

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

@@ -300,7 +300,7 @@ class _TensorMixin(_TensorMixinBase):
             # Note: tag.kind (feature or spatial) is independent from self.feature_dim_axis.
             if tag.batch and self.batch:
                 assert tag.batch == self.batch or self.batch.is_broadcast()
-            if tag.dyn_size_ext:
+            if tag.dyn_size_ext is not None:
                 assert tag.dyn_size_ext.dtype in {"int32", "int64"}
                 if tag.dyn_size_ext.have_batch_axis():
                     assert tag.batch == tag.dyn_size_ext.batch
@@ -803,7 +803,7 @@ class _TensorMixin(_TensorMixinBase):
             if batch:
                 batch_dim_ = batch.dim
             elif dim_tag:
-                if dim_tag.dyn_size_ext:
+                if dim_tag.dyn_size_ext is not None:
                     assert dim_tag.dyn_size_ext.dims == ()
                     assert dim_tag.dyn_size_ext.raw_tensor is not None
                     batch_dim_ = dim_tag.dyn_size_ext.raw_tensor
@@ -1788,7 +1788,7 @@ class _TensorMixin(_TensorMixinBase):
         if self.sparse_dim and self.sparse_dim not in self_dim_tags:
             dims.add(_m.ImplicitSparseDim(self.sparse_dim))
         for dim in self.dim_tags:
-            if dim.dyn_size_ext:
+            if dim.dyn_size_ext is not None:
                 for dim_ in dim.dyn_size_ext.dim_tags:
                     if dim_ not in self_dim_tags:
                         dims.add(_m.ImplicitDynSizeDim(dim_))
@@ -2791,7 +2791,7 @@ class _TensorMixin(_TensorMixinBase):
         assert self.time_dim_axis is not None
         dim = self._dims[self.time_dim_axis]
         assert isinstance(dim, Dim)
-        if dim.dyn_size_ext:
+        if dim.dyn_size_ext is not None:
             if dim.dyn_size_ext.raw_tensor is None:
                 dim.complete_dyn_size()
             assert dim.dyn_size_ext.raw_tensor is not None
@@ -3699,7 +3699,7 @@ def _create_size_placeholder(name, axis_wo_b, tag, batch_dim):
 
     with reuse_name_scope("extern_data/placeholders/%s" % name, absolute=True):
         dyn_size_name = "%s_dim%i_size" % (name, axis_wo_b)
-        if not tag.dyn_size_ext:
+        if tag.dyn_size_ext is None:
             dyn_size_ext = _t.Tensor(
                 name=dyn_size_name,
                 dtype=_t.Tensor.size_dtype,

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

@@ -83,7 +83,7 @@ class Dim(_DimMixin):
             self.dyn_size_ext = dimension.copy()
         else:
             raise TypeError(f"unexpected dimension type: {type(dimension)}")
-        if not name and not description and self.dyn_size_ext:
+        if not name and not description and self.dyn_size_ext is not None:
             name = self.dyn_size_ext.name
         self.name = name or description
         self._dyn_size_max_value = None

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

@@ -107,7 +107,7 @@ class TensorDict:
                             dim_value, expected_value_type
                         ), f"key {key_} {dim}: unexpected {type(dim_value)}, expected {expected_value_type}"
                         out[key_] = dim_value
-                elif dim.dyn_size_ext:
+                elif dim.dyn_size_ext is not None:
                     if include_scalar_dyn_sizes or dim.dyn_size_ext.dims:
                         assert isinstance(dim.dyn_size_ext.raw_tensor, expected_value_type), (
                             f"key {key_} {dim} {dim.dyn_size_ext}:"
@@ -147,9 +147,9 @@ class TensorDict:
                     continue
                 key_ = f"{key}:size{i}"
                 dim.reset_raw(only_self=True)
-                if dim.is_batch_dim() and not dim.dyn_size_ext:
+                if dim.is_batch_dim() and dim.dyn_size_ext is None:
                     dim.dyn_size_ext = Tensor("batch", [], dtype="int32")
-                if dim.dyn_size_ext:
+                if dim.dyn_size_ext is not None:
                     if not with_scalar_dyn_sizes and not dim.dyn_size_ext.dims:
                         pass
                     else:

{returnn-1.20250122.105051 → returnn-1.20250122.134518}/returnn/tensor/utils.py

@@ -51,11 +51,11 @@ def tensor_fill_random_numpy_(
         filled_this_round = False
 
         for dim in x.dims:
-            if dim.is_batch_dim() and not dim.dyn_size_ext:
+            if dim.is_batch_dim() and dim.dyn_size_ext is None:
                 dim.dyn_size_ext = Tensor("batch", [], dtype="int32")
-            if dim.is_dynamic() and not dim.dyn_size_ext:
+            if dim.is_dynamic() and dim.dyn_size_ext is None:
                 dim.dyn_size_ext = Tensor(dim.name or "time", dims=[batch_dim], dtype="int32")
-            if not dim.dyn_size_ext:
+            if dim.dyn_size_ext is None:
                 continue
             if tensor_fill_random_numpy_(
                 dim.dyn_size_ext,

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

@@ -746,7 +746,7 @@ class ReturnnLayersBackend(Backend[Layer]):
     @staticmethod
     def range_over_dim(dim: Dim, *, dtype: Optional[str] = None, device: Optional[str] = None) -> Tensor:
         """range over dim"""
-        if not dtype and dim.dyn_size_ext:
+        if not dtype and dim.dyn_size_ext is not None:
             dtype = dim.dyn_size_ext.dtype
         if not dtype:
             dtype = rf.get_default_array_index_dtype()

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

@@ -1098,7 +1098,7 @@ class _NetDictBuilderCtx:
                     continue
                 # We need dyn_size_ext to know the implicit dims, to correctly set out_shape.
                 # If dyn_size_ext is not set yet, try to complete it.
-                if not dim.dyn_size_ext:
+                if dim.dyn_size_ext is None:
                     dim.complete_dyn_size()
                 assert (
                     dim.dyn_size_ext

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

@@ -247,7 +247,7 @@ class Loop:
         """
         assert not self.end_ref, f"{self}.end() can only be called once"
         assert source.dtype == "bool", f"{self}: end expects boolean condition, got {source}"
-        if not self.axis.dyn_size_ext:
+        if self.axis.dyn_size_ext is None:
             dyn_size_ext = source.copy_template()
             dyn_size_ext.dtype = "int32"
             if dyn_size_ext.control_flow_ctx:

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

@@ -305,7 +305,7 @@ def register_extern_data(data: Tensor[rfl.Layer]):
         root_scope = rfl.Layer.top().root  # must exist
         _get_raw_layer_by_name(f"data:{data.name}", scope=root_scope, data=data)
     for i, (tag, orig_tag) in enumerate(zip(data.dim_tags, orig_dim_tags)):
-        if not tag.is_batch_dim() and tag.is_dynamic() and not tag.dyn_size_ext:
+        if not tag.is_batch_dim() and tag.is_dynamic() and tag.dyn_size_ext is None:
             # Undefined dynamic dim tag. Set default data template.
             orig_tag.dyn_size_ext = tag.dyn_size_ext = Tensor(
                 name=f"{tag.name or (data.name + f'[{i}]')}_default_dyn_size_ext",

{returnn-1.20250122.105051 → returnn-1.20250122.134518}/returnn/tf/frontend_low_level/_backend.py

@@ -438,7 +438,7 @@ class TFBackend(Backend[tf.Tensor]):
         :param device:
         :return: range over dim
         """
-        if not dtype and dim.dyn_size_ext:
+        if not dtype and dim.dyn_size_ext is not None:
             dtype = dim.dyn_size_ext.dtype
         if not dtype:
             dtype = rf.get_default_array_index_dtype()

{returnn-1.20250122.105051 → returnn-1.20250122.134518}/returnn/tf/layers/base.py

@@ -829,7 +829,7 @@ class LayerBase:
                     assert not out_shape, "out_shape %r must be empty if not a set" % (out_shape,)
                 out_shape = set(out_shape)
                 out_shape.add(OptionalDim(over_rec_time_dim))
-                if over_rec_time_dim.dyn_size_ext:
+                if over_rec_time_dim.dyn_size_ext is not None:
                     for tag in over_rec_time_dim.dyn_size_ext.dim_tags:
                         if tag not in [d.tag if isinstance(d, _MarkedDim) else d for d in out_shape]:
                             out_shape.add(OptionalDim(tag))

{returnn-1.20250122.105051 → returnn-1.20250122.134518}/returnn/tf/layers/basic.py

@@ -2401,7 +2401,7 @@ class LengthLayer(LayerBase):
                 sparse=sparse,
                 dim=None if sparse else NotSpecified,
             )
-        if not dim.dyn_size_ext:  # yet undefined
+        if dim.dyn_size_ext is None:  # yet undefined
             return Data(
                 name="%s_length" % name,
                 shape=(),
@@ -4503,7 +4503,7 @@ class MergeDimsLayer(_ConcatInputLayer):
             return  # should be handled already
         if target_tag.dimension is not None:  # static
             return  # should be handled already
-        if target_tag.dyn_size_ext:
+        if target_tag.dyn_size_ext is not None:
             return  # handled already
 
         out_size = None
@@ -5690,7 +5690,7 @@ class RepeatLayer(_ConcatInputLayer):
             out_dim_.declare_same_as(out_dim)
         if data.batch:
             out_dim_ = out_dim_.get_for_batch_ctx(data.batch, data.control_flow_ctx)
-        if tag.dyn_size_ext and not out_dim_.dyn_size_ext:
+        if tag.dyn_size_ext and out_dim_.dyn_size_ext is None:
             out_dim_.dyn_size_ext = tag.dyn_size_ext.copy_template()
         return data.copy_template_replace_dim_tag(axis=data.get_batch_axis(0), new_dim_tag=out_dim_)
 
@@ -6009,7 +6009,7 @@ class ReinterpretDataLayer(_ConcatInputLayer):
                     new_dyn_size_ext.placeholder = tf.identity(
                         new_dyn_size_ext.placeholder, name=get_valid_scope_name_from_str(new_dyn_size_ext.name)
                     )
-                if new_tag.dyn_size_ext:
+                if new_tag.dyn_size_ext is not None:
                     assert new_dyn_size_ext.dim_tags == new_tag.dyn_size_ext.dim_tags
                 new_tag.dyn_size_ext = new_dyn_size_ext
                 new_tag.set_tag_on_size_tensor(new_dyn_size_ext.placeholder)

{returnn-1.20250122.105051 → returnn-1.20250122.134518}/returnn/tf/layers/rec.py

@@ -1891,9 +1891,9 @@ class _SubnetworkRecCell:
                                     assert old_dim.is_dynamic_seq_length() and new_dim.is_dynamic_seq_length()
                                     if new_dim.dyn_size_ext and new_dim.dyn_size_ext.raw_tensor is not None:
                                         continue
-                                    if not old_dim.dyn_size_ext:
+                                    if old_dim.dyn_size_ext is None:
                                         continue
-                                    if not new_dim.dyn_size_ext:
+                                    if new_dim.dyn_size_ext is None:
                                         out_dims[new_axis] = old_dim
                                         continue
                                     if old_dim.dyn_size_ext.raw_tensor is not None:
@@ -2488,7 +2488,7 @@ class _SubnetworkRecCell:
             with tf.name_scope(layer.tf_scope_name):
                 out = layer.output.copy_as_batch_major().copy_with_time_dim_axis(1)  # [B,T,...]
                 time_dim = out.dim_tags[1]
-                if time_dim.dyn_size_ext:
+                if time_dim.dyn_size_ext is not None:
                     indices = time_dim.dyn_size_ext.copy()
                 else:
                     indices = Data.from_tensor(tf_util.get_shape_dim(out.placeholder, 0))

{returnn-1.20250122.105051 → returnn-1.20250122.134518}/returnn/torch/engine.py

@@ -1245,7 +1245,7 @@ class Engine(EngineBase):
             In the callback, we pass each sequence without the batch dim,
             so we must adapt the dim tags.
             """
-            if not dim.dyn_size_ext:
+            if dim.dyn_size_ext is None:
                 return dim
             if batch_dim not in dim.dyn_size_ext.dims:
                 return dim

{returnn-1.20250122.105051 → returnn-1.20250122.134518}/returnn/torch/frontend/_backend.py

@@ -998,7 +998,7 @@ class TorchBackend(Backend[torch.Tensor]):
         else:
             raise TypeError(f"Unsupported type for indices: {type(indices)}")
         if clip_to_valid:
-            if axis.dyn_size_ext:
+            if axis.dyn_size_ext is not None:
                 indices = rf.clip_by_value(
                     indices, 0, axis.get_dyn_size_ext_for_device(indices.device) - 1, allow_broadcast_all_sources=True
                 )
@@ -1434,7 +1434,7 @@ class TorchBackend(Backend[torch.Tensor]):
         :param device:
         :return: tensor with shape [dim]
         """
-        if not dtype and dim.dyn_size_ext:
+        if not dtype and dim.dyn_size_ext is not None:
             dtype = dim.dyn_size_ext.dtype
         if not dtype:
             dtype = rf.get_default_array_index_dtype()
@@ -1736,7 +1736,7 @@ class TorchBackend(Backend[torch.Tensor]):
             out_raw = masked_select(in_raw, mask_raw, mask_len=known_mask_len)
         if not out_dim:
             out_dim = Dim(None, name="masked_select")
-        if not out_dim.dyn_size_ext:
+        if out_dim.dyn_size_ext is None:
             out_dim.dyn_size_ext = Tensor("masked_select_size", dims=(), dtype="int64")
         if out_dim.dyn_size_ext.raw_tensor is None:
             out_dim.dyn_size_ext.raw_tensor = torch.tensor(out_raw.shape[0], dtype=torch.int64)

{returnn-1.20250122.105051 → returnn-1.20250122.134518}/returnn/torch/util/exception_helper.py

@@ -45,7 +45,7 @@ def help_on_torch_exception(
                 if dim in covered_dim_tags:
                     continue
                 covered_dim_tags.add(dim)
-                if not dim.dyn_size_ext:
+                if dim.dyn_size_ext is None:
                     continue
                 info, _ = _help_data_or_array(dim.dyn_size_ext.raw_tensor)
                 exc_ext.append(f"    dim {dim.short_repr()} size: {info}")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: returnn
-Version: 1.20250122.105051
+Version: 1.20250122.134518
 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.105051 → returnn-1.20250122.134518}/tests/rf_utils.py

@@ -271,7 +271,7 @@ def _dim_is_scalar_size(dim: Dim) -> bool:
     """dim is scalar size"""
     if dim.size is not None:
         return True
-    if dim.dyn_size_ext:
+    if dim.dyn_size_ext is not None:
         return dim.dyn_size_ext.dims == ()
     return False
 
@@ -280,7 +280,7 @@ def _dim_scalar_size(dim: Dim) -> int:
     """dim scalar size"""
     if dim.size is not None:
         return dim.size
-    if dim.dyn_size_ext:
+    if dim.dyn_size_ext is not None:
         assert dim.dyn_size_ext.dims == ()
         return dim.dyn_size_ext.raw_tensor
     raise Exception(f"dim {dim} has no known size")
@@ -293,7 +293,7 @@ def _pad_mask_zeros(x: Union[TensorDict, Tensor, Dim]):
         return
 
     if isinstance(x, Dim):
-        if x.dyn_size_ext:
+        if x.dyn_size_ext is not None:
             _pad_mask_zeros(x.dyn_size_ext)
         return
 

{returnn-1.20250122.105051 → returnn-1.20250122.134518}/tests/test_TFUtil.py

@@ -1647,7 +1647,7 @@ def test_ExternData_ext_Data_batch_info():
             x.batch == x.dim_tags[1].batch,
             x.dim_tags[1].dyn_size_ext,
         )
-        if not x.dim_tags[1].dyn_size_ext:
+        if not x.dim_tags[1].dyn_size_ext is not None:
             x.dim_tags[1].dyn_size_ext = Data(
                 name="x_default_dyn_size_ext_new", dim_tags=[batch_dim], dtype=Data.size_dtype, batch=x.batch
             )

{returnn-1.20250122.105051 → returnn-1.20250122.134518}/tests/test_rf_rec.py

@@ -242,7 +242,7 @@ def test_zoneout_lstm_tf_layers_vs_rf_pt():
             for i, tag in enumerate(out.dim_tags):
                 if tag.is_batch_dim():
                     fetches[f"layer:{old_layer_name}:size{i}"] = tag.get_dim_value()
-                elif tag.dyn_size_ext:
+                elif tag.dyn_size_ext is not None:
                     old_model_outputs_data[f"{old_layer_name}:size{i}"] = tag.dyn_size_ext
                     fetches[f"layer:{old_layer_name}:size{i}"] = tag.dyn_size_ext.placeholder
         old_model_outputs_fetch = session.run(fetches, feed_dict=feed_dict)

{returnn-1.20250122.105051 → returnn-1.20250122.134518}/tools/torch_export_to_onnx.py

@@ -246,7 +246,7 @@ def main():
         for i, dim in enumerate(v.dims):
             if dim.dyn_size_ext and dim.dyn_size_ext.dims == ():
                 continue
-            if dim.dyn_size_ext:
+            if dim.dyn_size_ext is not None:
                 dynamic_axes[f"{k}:size{i}"] = {
                     j: dim_.name for j, dim_ in enumerate(dim.dyn_size_ext.dims) if dim_.is_dynamic()
                 }

returnn-1.20250122.105051/_setup_info_generated.py

@@ -1,2 +0,0 @@
-version = '1.20250122.105051'
-long_version = '1.20250122.105051+git.e0ca139'