returnn 1.20250830.114445__py3-none-any.whl → 1.20250902.10950__py3-none-any.whl

returnn/PKG-INFO

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

returnn/_setup_info_generated.py

@@ -1,2 +1,2 @@
-version = '1.20250830.114445'
-long_version = '1.20250830.114445+git.24547d9'
+version = '1.20250902.010950'
+long_version = '1.20250902.010950+git.9d5debf'

returnn/tensor/_dim_extra.py

@@ -2082,7 +2082,7 @@ class _DimMixin:
         :return: self + other. note that this is not commutative, i.e. different from other + self.
         :rtype: Dim
         """
-        if isinstance(other, int) and other == 0:
+        if _is_const_dim_value(other, 0):
             return self
         cache_key = ("add", other)
         cache = self.get_same_base()._make_extra().cache_dim_math
@@ -2090,11 +2090,11 @@ class _DimMixin:
         if cache_entry:
             cache_entry.complete_dyn_size()
             return cache_entry
-        term = _OpLinearTerm.from_dim(self)
-        term.extend_add_sub_(other, kind="add", right=True)
-        dim = term.as_dim()
-        cache[cache_key] = dim
-        return dim
+        res = _MathFindMatchingAdditive(start=self, right=True, other=other).search_and_maybe_replace()
+        if not res:
+            res = _math_get_dim_via_bin_op([self, other], "add")
+        cache[cache_key] = res
+        return res
 
     def __radd__(self: Dim, other):
         """
@@ -2102,7 +2102,7 @@ class _DimMixin:
         :return: other + self
         :rtype: Dim
         """
-        if isinstance(other, int) and other == 0:
+        if _is_const_dim_value(other, 0):
             return self
         cache_key = ("add_left", other)
         cache = self.get_same_base()._make_extra().cache_dim_math
@@ -2110,18 +2110,18 @@ class _DimMixin:
         if cache_entry:
             cache_entry.complete_dyn_size()
             return cache_entry
-        term = _OpLinearTerm.from_dim(self)
-        term.extend_add_sub_(other, kind="add", right=False)
-        dim = term.as_dim()
-        cache[cache_key] = dim
-        return dim
+        res = _MathFindMatchingAdditive(start=self, right=False, other=other).search_and_maybe_replace()
+        if not res:
+            res = _math_get_dim_via_bin_op([other, self], "add")
+        cache[cache_key] = res
+        return res
 
     def __sub__(self, other):
         """
         :param Dim|int other:
         :rtype: Dim
         """
-        if isinstance(other, int) and other == 0:
+        if _is_const_dim_value(other, 0):
             return self
         return self.sub_right(other)
 
@@ -2131,19 +2131,24 @@ class _DimMixin:
         :return: self - other
         :rtype: Dim
         """
-        if isinstance(other, int) and other == 0:
+        if _is_const_dim_value(other, 0):
             return self
+        if (
+            self.derived_from_op
+            and self.derived_from_op.kind == "add"
+            and len(self.derived_from_op.inputs) == 2
+            and _dim_or_const_equal(other, self.derived_from_op.inputs[1])
+        ):
+            return self.derived_from_op.inputs[0]
         cache_key = ("sub", other)
         cache = self.get_same_base()._make_extra().cache_dim_math
         cache_entry = cache.get(cache_key, None)
         if cache_entry:
             cache_entry.complete_dyn_size()
             return cache_entry
-        term = _OpLinearTerm.from_dim(self)
-        term.extend_add_sub_(other, kind="sub", right=True)
-        dim = term.as_dim()
-        cache[cache_key] = dim
-        return dim
+        res = self + (-other)
+        cache[cache_key] = res
+        return res
 
     def sub_left(self: Dim, other):
         """
@@ -2151,44 +2156,55 @@ class _DimMixin:
         :return: (-other) + self
         :rtype: Dim
         """
-        if isinstance(other, int) and other == 0:
+        if _is_const_dim_value(other, 0):
             return self
+        if (
+            self.derived_from_op
+            and self.derived_from_op.kind == "add"
+            and len(self.derived_from_op.inputs) == 2
+            and _dim_or_const_equal(other, self.derived_from_op.inputs[0])
+        ):
+            return self.derived_from_op.inputs[1]
         cache_key = ("sub_left", other)
         cache = self.get_same_base()._make_extra().cache_dim_math
         cache_entry = cache.get(cache_key, None)
         if cache_entry:
             cache_entry.complete_dyn_size()
             return cache_entry
-        term = _OpLinearTerm.from_dim(self)
-        term.extend_add_sub_(other, kind="sub", right=False)
-        dim = term.as_dim()
-        cache[cache_key] = dim
-        return dim
+        res = (-other) + self
+        cache[cache_key] = res
+        return res
 
     def __mul__(self: Dim, other):
         """
         :param Dim|int other:
         :rtype: Dim
         """
+        if isinstance(other, _d.Dim) and other.is_constant_static_dim():
+            other = other.dimension  # makes matching easier
         if isinstance(other, int) and other == 1:
             return self
+        if self.is_constant_static_dim() and isinstance(other, _d.Dim):
+            return self.dimension * other  # use rmul
         cache_key = ("mul", other)
         cache = self.get_same_base()._make_extra().cache_dim_math
         cache_entry = cache.get(cache_key, None)
         if cache_entry:
             cache_entry.complete_dyn_size()
             return cache_entry
-        term = _OpLinearTerm.from_dim(self)
-        term.extend_mul_div_(other, kind="mul", right=True)
-        dim = term.as_dim()
-        cache[cache_key] = dim
-        return dim
+        res = _math_find_matching_mult(start=self, right=True, other=other)
+        if not res:
+            res = _math_get_dim_via_bin_op([self, other], "mul")
+        cache[cache_key] = res
+        return res
 
     def __rmul__(self: Dim, other):
         """
         :param Dim|int other:
         :rtype: Dim
         """
+        if isinstance(other, _d.Dim) and other.is_constant_static_dim():
+            other = other.dimension  # makes matching easier
         if isinstance(other, int) and other == 1:
             return self
         cache_key = ("mul_left", other)
@@ -2197,38 +2213,45 @@ class _DimMixin:
         if cache_entry:
             cache_entry.complete_dyn_size()
             return cache_entry
-        term = _OpLinearTerm.from_dim(self)
-        term.extend_mul_div_(other, kind="mul", right=False)
-        dim = term.as_dim()
-        cache[cache_key] = dim
-        return dim
+        res = _math_find_matching_mult(start=self, right=False, other=other)
+        if not res:
+            res = _math_get_dim_via_bin_op([other, self], "mul")
+        cache[cache_key] = res
+        return res
 
     def __floordiv__(self: Dim, other):
         """
         :param Dim|int other:
         :rtype: Dim
         """
+        if isinstance(other, _d.Dim) and other.is_constant_static_dim():
+            other = other.dimension  # makes matching easier
         if isinstance(other, int) and other == 1:
             return self
+        if (
+            self.derived_from_op
+            and self.derived_from_op.kind == "mul"
+            and len(self.derived_from_op.inputs) == 2
+            and _dim_or_const_equal(other, self.derived_from_op.inputs[1])
+        ):
+            return self.derived_from_op.inputs[0]
         cache_key = ("floordiv", other)
         cache = self.get_same_base()._make_extra().cache_dim_math
         cache_entry = cache.get(cache_key, None)
         if cache_entry:
             cache_entry.complete_dyn_size()
             return cache_entry
-        term = _OpLinearTerm.from_dim(self)
-        term.extend_mul_div_(other, kind="floordiv", right=True)
-        dim = term.as_dim()
-        cache[cache_key] = dim
-        return dim
+        res = _math_find_matching_div(start=self, right=True, other=other, kind="floordiv")
+        if not res:
+            res = _math_get_dim_via_bin_op([self, other], "floordiv")
+        cache[cache_key] = res
+        return res
 
     def __truediv__(self, other):
         """
         :param Dim|int other:
         :rtype: Dim
         """
-        if isinstance(other, int) and other == 1:
-            return self
         return self.div_right(other)
 
     def div_left(self: Dim, other):
@@ -2236,76 +2259,112 @@ class _DimMixin:
         :param Dim|int other:
         :rtype: Dim
         """
+        if isinstance(other, _d.Dim) and other.is_constant_static_dim():
+            other = other.dimension  # makes matching easier
         if isinstance(other, int) and other == 1:
             return self
+        if (
+            self.derived_from_op
+            and self.derived_from_op.kind == "mul"
+            and len(self.derived_from_op.inputs) == 2
+            and _dim_or_const_equal(other, self.derived_from_op.inputs[0])
+        ):
+            return self.derived_from_op.inputs[1]
         cache_key = ("truediv_left", other)
         cache = self.get_same_base()._make_extra().cache_dim_math
         cache_entry = cache.get(cache_key, None)
         if cache_entry:
             cache_entry.complete_dyn_size()
             return cache_entry
-        term = _OpLinearTerm.from_dim(self)
-        term.extend_mul_div_(other, kind="truediv", right=False)
-        dim = term.as_dim()
-        cache[cache_key] = dim
-        return dim
+        res = _math_find_matching_div(start=self, right=True, other=other, kind="truediv_left")
+        if not res:
+            res = _math_get_dim_via_bin_op([self, other], "truediv_left")
+        cache[cache_key] = res
+        return res
 
     def div_right(self: Dim, other):
         """
         :param Dim|int other:
         :rtype: Dim
         """
+        if isinstance(other, _d.Dim) and other.is_constant_static_dim():
+            other = other.dimension  # makes matching easier
         if isinstance(other, int) and other == 1:
             return self
+        if (
+            self.derived_from_op
+            and self.derived_from_op.kind == "mul"
+            and len(self.derived_from_op.inputs) == 2
+            and _dim_or_const_equal(other, self.derived_from_op.inputs[1])
+        ):
+            return self.derived_from_op.inputs[0]
         cache_key = ("truediv", other)
         cache = self.get_same_base()._make_extra().cache_dim_math
         cache_entry = cache.get(cache_key, None)
         if cache_entry:
             cache_entry.complete_dyn_size()
             return cache_entry
-        term = _OpLinearTerm.from_dim(self)
-        term.extend_mul_div_(other, kind="truediv", right=True)
-        dim = term.as_dim()
-        cache[cache_key] = dim
-        return dim
+        res = _math_find_matching_div(start=self, right=True, other=other, kind="truediv")
+        if not res:
+            res = _math_get_dim_via_bin_op([self, other], "truediv")
+        cache[cache_key] = res
+        return res
 
     def ceildiv_left(self: Dim, other):
         """
         :param Dim|int other:
         :rtype: Dim
         """
+        if isinstance(other, _d.Dim) and other.is_constant_static_dim():
+            other = other.dimension  # makes matching easier
         if isinstance(other, int) and other == 1:
             return self
+        if (
+            self.derived_from_op
+            and self.derived_from_op.kind == "mul"
+            and len(self.derived_from_op.inputs) == 2
+            and _dim_or_const_equal(other, self.derived_from_op.inputs[0])
+        ):
+            return self.derived_from_op.inputs[1]
         cache_key = ("ceildiv_left", other)
         cache = self.get_same_base()._make_extra().cache_dim_math
         cache_entry = cache.get(cache_key, None)
         if cache_entry:
             cache_entry.complete_dyn_size()
             return cache_entry
-        term = _OpLinearTerm.from_dim(self)
-        term.extend_mul_div_(other, kind="ceildiv", right=False)
-        dim = term.as_dim()
-        cache[cache_key] = dim
-        return dim
+        res = _math_find_matching_div(start=self, right=True, other=other, kind="ceildiv_left")
+        if not res:
+            res = _math_get_dim_via_bin_op([self, other], "ceildiv_left")
+        cache[cache_key] = res
+        return res
 
     def ceildiv_right(self: Dim, other):
         """
         :param Dim|int other:
         :rtype: Dim
         """
+        if isinstance(other, _d.Dim) and other.is_constant_static_dim():
+            other = other.dimension  # makes matching easier
         if isinstance(other, int) and other == 1:
             return self
+        if (
+            self.derived_from_op
+            and self.derived_from_op.kind == "mul"
+            and len(self.derived_from_op.inputs) == 2
+            and _dim_or_const_equal(other, self.derived_from_op.inputs[1])
+        ):
+            return self.derived_from_op.inputs[0]
         cache_key = ("ceildiv", other)
         cache = self.get_same_base()._make_extra().cache_dim_math
         cache_entry = cache.get(cache_key, None)
         if cache_entry:
             cache_entry.complete_dyn_size()
             return cache_entry
-        term = _OpLinearTerm.from_dim(self)
-        term.extend_mul_div_(other, kind="ceildiv", right=True)
-        dim = term.as_dim()
-        cache[cache_key] = dim
-        return dim
+        res = _math_find_matching_div(start=self, right=True, other=other, kind="ceildiv")
+        if not res:
+            res = _math_get_dim_via_bin_op([self, other], "ceildiv")
+        cache[cache_key] = res
+        return res
 
     def __neg__(self):
         """
@@ -2348,6 +2407,7 @@ def _make_constant_static_dim(value, kind=None):
     :param Entity|None kind:
     :rtype: Dim
     """
+    assert isinstance(value, int)
     return _d.Dim(
         dimension=value,
         kind=kind or DimTypes.Unspecified,
@@ -2357,30 +2417,188 @@ def _make_constant_static_dim(value, kind=None):
     )
 
 
-def _math_get_dim_via_bin_op(a: Dim, b: Dim, op_kind: str) -> Dim:
-    assert op_kind in {"add", "mul"}
-    op_kind_ = op_kind
-    a_, b_ = a, b
-    if a.is_constant_static_dim() and not b.is_constant_static_dim():
-        op_kind_ = op_kind + "_left"
-        a_, b_ = b, a
-    # noinspection PyProtectedMember
-    cache, cache_key, res = a_._cache_dim_math_get(op_kind_, b_)
-    if res:
-        return res
-    if a.dimension is not None and b.dimension is not None:
-        dim_value = getattr(operator, op_kind)(a.dimension, b.dimension)
+def _dim_or_const_equal(a: Union[Dim, int], b: Union[Dim, int]) -> bool:
+    if isinstance(a, int):
+        if isinstance(b, int):
+            return a == b
+        elif isinstance(b, _d.Dim):
+            return a == b.dimension and b.is_constant_static_dim()
+        else:
+            raise TypeError(f"unexpected b type {type(b)}")
+    elif isinstance(a, _d.Dim):
+        if a.is_constant_static_dim():
+            if isinstance(b, int):
+                return a.dimension == b
+            elif isinstance(b, _d.Dim):
+                return a.dimension == b.dimension and b.is_constant_static_dim()
+            else:
+                raise TypeError(f"unexpected b type {type(b)}")
+        else:
+            if isinstance(b, int):
+                return False
+            elif isinstance(b, _d.Dim):
+                return a == b
+            else:
+                raise TypeError(f"unexpected b type {type(b)}")
+    else:
+        raise TypeError(f"unexpected a type {type(a)}")
+
+
+_BinOps = {
+    "add": operator.add,
+    "mul": operator.mul,
+    "sub": operator.sub,
+    "floordiv": operator.floordiv,
+    "truediv": operator.floordiv,
+    "truediv_left": operator.floordiv,
+    "ceildiv": lambda a, b: -(-a // b),
+    "ceildiv_left": lambda a, b: -(-a // b),
+}
+
+_BinOpStrs = {
+    "add": "+",
+    "mul": "*",
+    "sub": "-",
+    "floordiv": "//",
+    "truediv": "/",
+    "truediv_left": " /l ",
+    "ceildiv": "/",
+    "ceildiv_left": " /l ",
+}
+
+
+def _math_get_dim_via_bin_op(dims: Sequence[Union[Dim, int]], op_kind: str) -> Dim:
+    dims = [d if isinstance(d, _d.Dim) else _make_constant_static_dim(d) for d in dims]
+    if all(d.dimension is not None for d in dims):
+        op = _BinOps[op_kind]
+        dim_value = dims[0].dimension
+        for d in dims[1:]:
+            dim_value = op(dim_value, d.dimension)
     else:
         dim_value = None
-    res = _d.Dim(
-        kind=_get_merged_dim_kind((a, b)),
-        description=_get_description(a) + {"add": "+", "mul": "*"}[op_kind] + _get_description(b),
+    if all(d.is_constant_static_dim() for d in dims):
+        return _make_constant_static_dim(dim_value, kind=_get_merged_dim_kind(dims))
+    desc = _BinOpStrs[op_kind].join(_get_description(d) for d in dims)
+    if op_kind.startswith("ceildiv"):
+        desc = f"⌈{desc}⌉"
+    return _d.Dim(
+        kind=_get_merged_dim_kind(dims),
+        description=desc,
         dimension=dim_value,
-        derived_from_op=Op(kind=op_kind, inputs=[a, b]),
-        derived_from_tag=_representative_tag((a, b)),
+        derived_from_op=Op(kind=op_kind, inputs=list(dims)),
+        derived_from_tag=_representative_tag(dims),
     )
-    cache[cache_key] = res
-    return res
+
+
+def _is_const_dim_value(d: Union[Dim, int], value: int) -> bool:
+    if isinstance(d, int):
+        return d == value
+    elif isinstance(d, _d.Dim):
+        return d.is_constant_static_dim() and d.dimension == value
+    else:
+        raise TypeError(f"unexpected type {type(d)}")
+
+
+class _MathFindMatchingAdditive:
+    def __init__(self, start: Dim, *, max_depth: int = 2, right: bool, other: Union[int, Dim]):
+        self.start = start
+        self.max_depth = max_depth
+        self.right = right
+        self.other = other
+
+    def _check_and_maybe_replace(self, candidate: Dim) -> Optional[Dim]:
+        """
+        Check and return potential replacement for candidate, when adding `other` to it.
+        """
+        other = self.other
+        if isinstance(other, int) or other.is_constant_static_dim():
+            if candidate.is_constant_static_dim():
+                return _math_get_dim_via_bin_op([candidate, other] if self.right else [other, candidate], "add")
+            return None
+        if candidate == other:
+            return candidate.__rmul__(2)
+        c_op = candidate.derived_from_op
+        if c_op and c_op.kind == "mul" and len(c_op.inputs) == 2 and c_op.inputs[1] == other:
+            factor = (c_op.inputs[0] + 1) if self.right else (1 + c_op.inputs[0])
+            if factor.is_constant_static_dim():
+                if factor.dimension == 0:
+                    return factor
+                factor = factor.dimension
+            return factor * c_op.inputs[1]
+        o_op = other.derived_from_op
+        if not o_op or o_op.kind != "mul" or len(o_op.inputs) != 2:
+            return None
+        o_base, other = o_op.inputs  # continue checking this
+        if candidate == other:
+            factor = (1 + o_base) if self.right else (o_base + 1)
+            if factor.is_constant_static_dim():
+                if factor.dimension == 0:
+                    return factor
+                factor = factor.dimension
+            return factor * candidate
+        if c_op and c_op.kind == "mul" and len(c_op.inputs) == 2 and c_op.inputs[1] == other:
+            factor = (c_op.inputs[0] + o_base) if self.right else (o_base + c_op.inputs[0])
+            if factor.is_constant_static_dim():
+                if factor.dimension == 0:
+                    return factor
+                factor = factor.dimension
+            return factor * c_op.inputs[1]
+        return None
+
+    def search_and_maybe_replace(self) -> Optional[Dim]:
+        """search"""
+        cur = self.start
+        depth = 0
+        history = []
+        while True:
+            res_cur = self._check_and_maybe_replace(cur)
+            if res_cur:
+                if depth > 0 and res_cur.is_constant_static_dim() and res_cur.dimension == 0:
+                    res_cur = history.pop(-1)
+                res = res_cur
+                for h in reversed(history):
+                    res = _math_get_dim_via_bin_op([h, res] if self.right else [res, h], "add")
+                return res
+            depth += 1
+            if depth > self.max_depth:
+                return None
+            op = cur.derived_from_op
+            if not op or op.kind != "add" or len(op.inputs) != 2:
+                return None
+            cur = op.inputs[1 if self.right else 0]
+            hist = op.inputs[0 if self.right else 1]
+            history.append(hist)
+
+
+def _math_find_matching_mult(start: Dim, other: Union[int, Dim], *, right: bool) -> Optional[Dim]:
+    if (isinstance(other, int) or other.is_constant_static_dim()) and start.is_constant_static_dim():
+        return _math_get_dim_via_bin_op([start, other] if right else [other, start], "mul")
+    c_op = start.derived_from_op
+    if c_op and c_op.kind == "mul" and len(c_op.inputs) == 2:
+        if right:
+            return c_op.inputs[0] * (c_op.inputs[1] * other)
+        else:
+            return (other * c_op.inputs[0]) * c_op.inputs[1]
+    return None
+
+
+_DivKindToMeth: Dict[str, Callable[[Dim, Dim], Dim]] = {
+    "truediv": _DimMixin.div_right,
+    "truediv_left": _DimMixin.div_left,
+    "ceildiv": _DimMixin.ceildiv_right,
+    "ceildiv_left": _DimMixin.ceildiv_left,
+    "floordiv": _DimMixin.__floordiv__,
+}
+
+
+def _math_find_matching_div(start: Dim, other: Union[int, Dim], *, right: bool, kind: str) -> Optional[Dim]:
+    if (isinstance(other, int) or other.is_constant_static_dim()) and start.is_constant_static_dim():
+        return _math_get_dim_via_bin_op([start, other] if right else [other, start], kind)
+    c_op = start.derived_from_op
+    if c_op and c_op.kind == kind and len(c_op.inputs) == 2:
+        meth = _DivKindToMeth[kind]
+        return meth(c_op.inputs[0], c_op.inputs[1] * other if right else other * c_op.inputs[1])
+    return None
 
 
 class Op:
@@ -2437,457 +2655,7 @@ def _get_description(dim, brackets=True):
     return "unnamed_%s_dim%s" % (dim.kind, dim.dimension if dim.dimension is not None else "?")
 
 
-class _OpMultTerm:
-    """
-    represents sth like a * b * c
-    """
-
-    @classmethod
-    def from_dim(cls, dim: Dim) -> _OpMultTerm:
-        """
-        :param dim:
-        :return: op mult term
-        """
-        dim = dim.get_same_base()
-        if dim.dimension == 1 and dim.is_constant_static_dim():
-            return cls.one()
-        if dim.derived_from_op and dim.derived_from_op.kind == "mul":
-            return cls(list(dim.derived_from_op.inputs))
-        return cls([dim])
-
-    @classmethod
-    def from_dim_factors(cls, dims: List[Dim]) -> _OpMultTerm:
-        """from dim factors"""
-        res = cls.one()
-        for d in dims:
-            res.extend_mul_div_(d, kind="mul", right=True)
-        return res
-
-    @classmethod
-    def one(cls) -> _OpMultTerm:
-        """1"""
-        return cls([])
-
-    def __init__(self, terms: List[Dim]):
-        self.terms = terms
-
-    def __hash__(self):
-        return hash(tuple(self.terms))
-
-    def __eq__(self, other):
-        """
-        :param _OpMultTerm other:
-        """
-        if isinstance(other, _OpMultTerm):
-            return self.terms == other.terms
-        return False
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def __repr__(self):
-        return "Dim._OpMultTerm(%r)" % (self.terms,)
-
-    @property
-    def dimension(self) -> Optional[int]:
-        """static dim or None"""
-        dim = 1
-        for part in self.terms:
-            if part.dimension is None:
-                return None
-            dim *= part.dimension
-        return dim
-
-    def base_term(self) -> Dim:
-        """base term (Dim)"""
-        assert self.terms
-        return self.terms[-1]
-
-    def is_one(self) -> bool:
-        """is 1"""
-        return not self.terms
-
-    def is_constant_static_dim(self) -> bool:
-        """is constant static dim"""
-        if not self.terms:
-            return True
-        return all(term.is_constant_static_dim() for term in self.terms)
-
-    def copy(self) -> _OpMultTerm:
-        """copy"""
-        return _OpMultTerm(list(self.terms))
-
-    def negative(self) -> _OpMultTerm:
-        """negative"""
-        if self.terms and self.terms[0].is_constant_static_dim() and self.terms[0].dimension == -1:
-            return _OpMultTerm(self.terms[1:])
-        res = self.copy()
-        res.extend_mul_div_(_make_constant_static_dim(-1), kind="mul", right=False)
-        return res
-
-    def divisible(self, other, right):
-        """
-        :param Dim other:
-        :param bool right:
-        :return: whether we can divide other, without remainder
-        :rtype: bool
-        """
-        if not self.terms:
-            return False
-        if other.derived_from_op and other.derived_from_op.kind == "mul":
-            tmp = self.copy()
-            for term in other.derived_from_op.inputs if right else reversed(other.derived_from_op.inputs):
-                if not tmp.divisible(term, right=right):
-                    return False
-                tmp.extend_mul_div_(term, kind="truediv", right=right)
-            return True
-        most_recent_term = self.terms[-1 if right else 0]
-        if other == most_recent_term:
-            return True
-        if most_recent_term.dimension is not None and other.dimension is not None:
-            if most_recent_term.dimension % other.dimension == 0:
-                return True
-        return False
-
-    def can_simplify(self, other, kind, right):
-        """
-        :param Dim other:
-        :param str kind:
-        :param bool right:
-        :return: whether we can simplify when applying this operation
-        :rtype: bool
-        """
-        if other.derived_from_op and other.derived_from_op.kind == "mul":
-            tmp = self.copy()
-            for term in other.derived_from_op.inputs if right else reversed(other.derived_from_op.inputs):
-                if not tmp.can_simplify(term, kind=kind, right=right):
-                    return False
-                tmp.extend_mul_div_(term, kind=kind, right=right)
-            return True
-        idx = self._simplify_term_idx(other, kind=kind, right=right)
-        return idx is not None
-
-    def _simplify_term_idx(self, other, kind, right):
-        """
-        :param Dim other:
-        :param str kind:
-        :param bool right:
-        :return: index of term to simplify
-        :rtype: int|None
-        """
-        if not self.terms:
-            return None
-        if kind == "mul":
-            # We want (b * a) // b != a.
-            # However, we want h * (2 * a // h) == 2 * a.
-            # So, for `mul`, and only for `mul`, check all terms, whether we can simplify some division-term.
-            for i, term in reversed(list(enumerate(self.terms))) if right else enumerate(self.terms):
-                assert isinstance(term, _d.Dim)
-                if term.derived_from_op:
-                    if term.derived_from_op.kind == "truediv_" + ("right" if right else "left"):
-                        if term.derived_from_op.inputs[-1] == other:
-                            return i
-                if other.derived_from_op:
-                    if other.derived_from_op.kind == "truediv_" + ("right" if not right else "left"):
-                        if other.derived_from_op.inputs[-1] == term:
-                            return i
-                if term.is_constant_static_dim() and other.is_constant_static_dim():
-                    return i
-        # For the last/first term, extra checks.
-        i = len(self.terms) - 1 if right else 0
-        term = self.terms[i]
-        if kind.endswith("div") and other == term:
-            return i
-        op_kind = kind + "_" + ("right" if right else "left")
-        if term.derived_from_op and term.derived_from_op.kind == op_kind:
-            return i
-        return None
-
-    def extend_mul_div_(self, other, kind, right):
-        """
-        :param Dim other:
-        :param str kind:
-        :param bool right:
-        """
-        assert kind in {"mul", "floordiv", "truediv", "ceildiv"}
-        if other.is_constant_static_dim() and other.dimension == 1:
-            return
-        if not self.terms:
-            if kind == "mul":
-                self.terms.append(other)
-            elif kind.endswith("div"):
-                self.terms = [_OpMultTerm.new_div_dim(self.as_dim(), other, kind=kind, right=right)]
-            return
-        if other.derived_from_op and other.derived_from_op.kind == "mul":
-            for term in other.derived_from_op.inputs if right else reversed(other.derived_from_op.inputs):
-                self.extend_mul_div_(term, kind=kind, right=right)
-            return
-        idx = self._simplify_term_idx(other, kind=kind, right=right)
-        if idx is not None:
-            term = self.terms[idx]
-            assert isinstance(term, _d.Dim)
-            if kind.endswith("div") and other == term:
-                self.terms.pop(idx)
-                return
-            if kind == "mul" and term.derived_from_op:
-                if term.derived_from_op.kind == "truediv_" + ("right" if right else "left"):
-                    if term.derived_from_op.inputs[-1] == other:
-                        self.terms[idx] = term.derived_from_op.inputs[0]
-                        return
-            if kind == "mul" and other.derived_from_op:
-                if other.derived_from_op.kind == "truediv_" + ("right" if not right else "left"):
-                    if other.derived_from_op.inputs[-1] == term:
-                        self.terms[idx] = other.derived_from_op.inputs[0]
-                        return
-            if term.is_constant_static_dim() and other.is_constant_static_dim():
-                if kind == "mul":
-                    if term.dimension * other.dimension == 1:
-                        self.terms.pop(idx)
-                        return
-                    self.terms[idx] = _make_constant_static_dim(term.dimension * other.dimension, kind=term.kind)
-                    return
-                if kind.endswith("div") and term.dimension % other.dimension == 0:
-                    self.terms[idx] = _make_constant_static_dim(term.dimension // other.dimension, kind=term.kind)
-                    return
-                # Fallback with generic handling.
-            op_kind = kind + "_" + ("right" if right else "left")
-            if kind.endswith("div") and term.derived_from_op and term.derived_from_op.kind == op_kind:
-                numerator = term.derived_from_op.inputs[0]
-                denominator = term.derived_from_op.inputs[1]
-                self.terms[idx] = _OpMultTerm.new_div_dim(numerator, denominator * other, kind=kind, right=right)
-                return
-        if kind.endswith("div"):
-            self.terms = [_OpMultTerm.new_div_dim(self.as_dim(), other, kind=kind, right=right)]
-            return
-        if kind == "mul":
-            if right:
-                self.terms.append(other)
-            else:
-                self.terms.insert(0, other)
-            return
-        assert False
-
-    @classmethod
-    def new_div_dim(cls, numerator, denominator, kind, right):
-        """
-        :param Dim numerator:
-        :param Dim denominator:
-        :param str kind: "floordiv" or "ceildiv" or "truediv"
-        :param bool right:
-        :rtype: Dim
-        """
-        dim_value = None
-        a = numerator.dimension
-        b = denominator.dimension
-        if a is not None and b is not None:
-            if kind == "floordiv":
-                dim_value = a // b
-            elif kind == "ceildiv":
-                dim_value = -(-a // b)
-                if a % b == 0 and right:
-                    kind = "floordiv"  # for nicer description, and does not matter
-            elif kind == "truediv":
-                if a % b != 0:
-                    raise ValueError(
-                        "%s truediv %s only allowed if the result is an integer" % (numerator, denominator)
-                    )
-                dim_value = a // b
-                if right:
-                    kind = "floordiv"  # for nicer description, and does not matter
-            else:
-                raise ValueError("invalid kind %r" % (kind,))
-        # noinspection PyProtectedMember
-        cache, cache_key, res = numerator._cache_dim_math_get(kind + ("" if right else "_left"), denominator)
-        if res:
-            return res
-        if kind == "floordiv" and right:
-            description = "%s//%s" % (_get_description(numerator), _get_description(denominator))
-        elif kind == "ceildiv" and right:
-            description = "⌈%s/%s⌉" % (_get_description(numerator), _get_description(denominator))
-        else:
-            description = "%s_%s(%s, %s)" % (
-                kind,
-                "right" if right else "left",
-                _get_description(numerator, brackets=False),
-                _get_description(denominator, brackets=False),
-            )
-        op_kind = kind
-        if a is not None and b is not None and a % b == 0:
-            op_kind = "truediv"  # makes some other checks simpler
-        op_kind += "_" + ("right" if right else "left")
-        res = _d.Dim(
-            description=description,
-            kind=numerator.kind,
-            dimension=dim_value,
-            derived_from_op=Op(kind=op_kind, inputs=[numerator, denominator]),
-            derived_from_tag=numerator,
-        )
-        cache[cache_key] = res
-        return res
-
-    def as_dim(self):
-        """
-        :rtype: Dim
-        """
-        if self.is_one():
-            return _make_constant_static_dim(1)
-        if len(self.terms) == 1:
-            return self.terms[0]
-        res = self.terms[0]
-        for operand in self.terms[1:]:
-            res = _math_get_dim_via_bin_op(res, operand, "mul")
-        return res
-
-
-class _OpLinearTerm:
-    """
-    Linear combination of :class:`_OpMultTerm`.
-    Represents sth like a * b + c of :class:`Dim`.
-    """
-
-    @classmethod
-    def from_dim(cls, dim: Dim) -> _OpLinearTerm:
-        """from dim"""
-        res = cls.zero()
-        res.extend_add_sub_(dim, kind="add", right=True)
-        return res
-
-    @classmethod
-    def zero(cls) -> _OpLinearTerm:
-        """0"""
-        return _OpLinearTerm([])
-
-    def __init__(self, terms: List[_OpMultTerm]):
-        self.terms = terms
-
-    def __hash__(self):
-        return hash(tuple(self.terms))
-
-    def __eq__(self, other):
-        if isinstance(other, _OpLinearTerm):
-            return self.terms == other.terms
-        return False
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def as_dim(self) -> Dim:
-        """as dim"""
-        if self.is_zero():
-            return _make_constant_static_dim(0)
-        if len(self.terms) == 1:
-            return self.terms[0].as_dim()
-        res = self.terms[0].as_dim()
-        for operand in self.terms[1:]:
-            res = _math_get_dim_via_bin_op(res, operand.as_dim(), "add")
-        return res
-
-    def __repr__(self):
-        return "Dim._OpLinearTerm(%r)" % (self.terms,)
-
-    def is_zero(self):
-        """
-        :rtype: bool
-        """
-        return not self.terms
-
-    def extend_add_sub_(self, other, kind, right):
-        """
-        :param Dim|int other:
-        :param str kind: "add" or "sub"
-        :param bool right: or left. right means self + other, left means other + self
-        """
-        assert kind in {"add", "sub"}
-        other = self._make_dim(other, kind=kind)
-        if other.is_constant_static_dim() and other.dimension == 0:
-            return
-        if other.derived_from_op and other.derived_from_op.kind == "add":
-            for other_ in other.derived_from_op.inputs if right else reversed(other.derived_from_op.inputs):
-                self.extend_add_sub_(other_, kind=kind, right=right)
-            return
-        term = _OpMultTerm.from_dim(other)
-        neg_term = term.negative()
-        if kind == "sub":
-            term, neg_term = neg_term, term
-        most_recent_term = self.terms[-1 if right else 0] if self.terms else None
-        if most_recent_term:
-            if most_recent_term == neg_term:
-                self.terms.pop(-1 if right else 0)
-                return
-            if most_recent_term.is_constant_static_dim() and term.is_constant_static_dim():
-                self.terms[-1 if right else 0] = _OpMultTerm.from_dim(
-                    _make_constant_static_dim(most_recent_term.dimension + term.dimension, kind=other.kind)
-                )
-                return
-            if most_recent_term.terms and term.terms and most_recent_term.terms[-1] == term.terms[-1]:
-                # Merge terms
-                a = _OpMultTerm.from_dim_factors(most_recent_term.terms[:-1]).as_dim()
-                b = _OpMultTerm.from_dim_factors(term.terms[:-1]).as_dim()
-                if a.is_constant_static_dim() and not b.is_constant_static_dim():
-                    a = a.dimension
-                elif b.is_constant_static_dim() and not a.is_constant_static_dim():
-                    b = b.dimension
-                res = _OpMultTerm.from_dim((a + b) if right else (b + a))
-                res.extend_mul_div_(term.terms[-1], kind="mul", right=True)
-                self.terms[-1 if right else 0] = res
-                return
-        if right:
-            self.terms.append(term)
-        else:
-            self.terms.insert(0, term)
-
-    def extend_mul_div_(self, other, kind, right):
-        """
-        :param Dim|int other:
-        :param str kind: "mul" or "ceildiv"
-        :param bool right: or left. right means self * other, left means other * self
-        """
-        assert kind in {"mul", "floordiv", "truediv", "ceildiv"}
-        other = self._make_dim(other, kind=kind)
-        if kind == "mul" and right:
-            if not all(term.can_simplify(other, kind=kind, right=right) for term in self.terms):
-                # Do it the other way around
-                self.terms, other = _OpLinearTerm.from_dim(other).terms, self.as_dim()
-                right = False
-        if other.is_constant_static_dim() and other.dimension == 1:
-            return
-        if kind.endswith("div") and len(self.terms) >= 2:
-            if any(not term.divisible(other, right=right) for term in self.terms):
-                self.terms = [
-                    _OpMultTerm.from_dim(_OpMultTerm.new_div_dim(self.as_dim(), other, kind=kind, right=right))
-                ]
-                return
-        for term in self.terms:
-            term.extend_mul_div_(other, kind=kind, right=right)
-
-    def _make_dim(self, other, kind):
-        """
-        :param Dim|int other:
-        :param str kind:
-        :rtype: Dim
-        """
-        if isinstance(other, int):
-            base_tag = self.representative_tag()
-            return _make_constant_static_dim(other, kind=base_tag.kind if base_tag else None)
-        elif isinstance(other, _d.Dim):
-            return other.get_same_base()
-        else:
-            raise TypeError("%s %s %s invalid for type %s" % (self, kind, other, type(other)))
-
-    def representative_tag(self):
-        """
-        :rtype: Dim|None
-        """
-        terms = [_representative_tag(term.terms) for term in self.terms]
-        return _representative_tag([term for term in terms if term])
-
-
-def _get_merged_dim_kind(dim_tags):
-    """
-    :param list[Dim]|tuple[Dim] dim_tags:
-    :return: dim kind
-    :rtype: Entity
-    """
+def _get_merged_dim_kind(dim_tags: Sequence[Dim]) -> Entity:
     if any(tag.is_batch_dim() for tag in dim_tags):
         return DimTypes.Batch
     elif any(tag.is_feature_dim() for tag in dim_tags):

returnn/torch/util/diagnose_gpu.py

@@ -8,6 +8,10 @@ import os
 import sys
 import gc
 import subprocess
+import signal
+import time
+import contextlib
+import multiprocessing
 import torch
 from returnn.util.better_exchook import better_exchook
 from returnn.util.basic import human_bytes_size
@@ -26,36 +30,39 @@ def print_available_devices(*, file: Optional[TextIO] = None):
         print("CUDA_VISIBLE_DEVICES is set to %r." % os.environ["CUDA_VISIBLE_DEVICES"], file=file)
         cuda_visible_devs = dict(enumerate([int(d) for d in os.environ["CUDA_VISIBLE_DEVICES"].split(",") if d]))
     else:
-        if torch.cuda.is_available():
-            print("CUDA_VISIBLE_DEVICES is not set.", file=file)
-
-    if torch.cuda.is_available():
-        print("Available CUDA devices:")
-        count = torch.cuda.device_count()
-        if cuda_visible_devs is not None and len(cuda_visible_devs) != count:
-            print(
-                f"(Mismatch between CUDA device count {count}"
-                f" and CUDA_VISIBLE_DEVICES {cuda_visible_devs} count {len(cuda_visible_devs)}?)",
-                file=file,
-            )
-        for i in range(count):
-            print(f"  {i + 1}/{count}: cuda:{i}", file=file)
-            props = torch.cuda.get_device_properties(i)
-            print(f"       name: {props.name}", file=file)
-            print(f"       total_memory: {human_bytes_size(props.total_memory)}", file=file)
-            print(f"       capability: {props.major}.{props.minor}", file=file)
-            if cuda_visible_devs is not None:
-                if len(cuda_visible_devs) == count:
-                    dev_idx_s = cuda_visible_devs[i]
-                else:
-                    dev_idx_s = "?"
+        with timeout("torch.cuda.is_available()"):
+            if torch.cuda.is_available():
+                print("CUDA_VISIBLE_DEVICES is not set.", file=file)
+
+    with timeout("torch.cuda.is_available()"):
+        if not torch.cuda.is_available():
+            print("(CUDA not available)", file=file)
+            return
+
+    print("Available CUDA devices:", file=file)
+    count = torch.cuda.device_count()
+    if cuda_visible_devs is not None and len(cuda_visible_devs) != count:
+        print(
+            f"(Mismatch between CUDA device count {count}"
+            f" and CUDA_VISIBLE_DEVICES {cuda_visible_devs} count {len(cuda_visible_devs)}?)",
+            file=file,
+        )
+    for i in range(count):
+        print(f"  {i + 1}/{count}: cuda:{i}", file=file)
+        props = torch.cuda.get_device_properties(i)
+        print(f"       name: {props.name}", file=file)
+        print(f"       total_memory: {human_bytes_size(props.total_memory)}", file=file)
+        print(f"       capability: {props.major}.{props.minor}", file=file)
+        if cuda_visible_devs is not None:
+            if len(cuda_visible_devs) == count:
+                dev_idx_s = cuda_visible_devs[i]
             else:
-                dev_idx_s = i
-            print(f"       device_index: {dev_idx_s}", file=file)
-        if not count:
-            print("  (None)")
-    else:
-        print("(CUDA not available)")
+                dev_idx_s = "?"
+        else:
+            dev_idx_s = i
+        print(f"       device_index: {dev_idx_s}", file=file)
+    if not count:
+        print("  (None)", file=file)
 
 
 def print_using_cuda_device_report(dev: Union[str, torch.device], *, file: Optional[TextIO] = None):
@@ -108,7 +115,7 @@ def diagnose_no_gpu() -> List[str]:
     except Exception as exc:
         print("nvidia-smi failed:", exc)
         better_exchook(*sys.exc_info(), debugshell=False)
-        res.append(f"nvidia-smi failed")
+        res.append("nvidia-smi failed")
 
     return res
 
@@ -152,4 +159,31 @@ def garbage_collect():
             f"alloc {human_bytes_size(torch.cuda.memory_allocated())}",
             f"reserved {human_bytes_size(torch.cuda.memory_reserved())}",
         ]
-        print(f"CUDA memory usage after triggered GC:", " ".join(stats))
+        print("CUDA memory usage after triggered GC:", " ".join(stats))
+
+
+@contextlib.contextmanager
+def timeout(info: str, *, seconds: int = 30):
+    """
+    Note: don't use signal handlers (e.g. signal.alarm) because unfortunately
+    potential hanging funcs will block the main thread and thus block the signal handler from executing.
+    Thus, we use a subprocess.
+
+    :param seconds:
+    :param info:
+    """
+    proc = multiprocessing.Process(
+        target=_timeout_handler, kwargs={"seconds": seconds, "proc_id": os.getpid(), "info": info}
+    )
+    proc.start()
+    try:
+        yield
+    finally:
+        proc.terminate()
+        proc.join()
+
+
+def _timeout_handler(*, seconds: Union[float, int], proc_id: int, info: str):
+    time.sleep(seconds)
+    print(f"ERROR: {info}: Timeout handler after {seconds} seconds, killing proc {proc_id}.", file=sys.stderr)
+    os.kill(proc_id, signal.SIGABRT)

{returnn-1.20250830.114445.dist-info → returnn-1.20250902.10950.dist-info}/METADATA

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

{returnn-1.20250830.114445.dist-info → returnn-1.20250902.10950.dist-info}/RECORD

@@ -1,9 +1,9 @@
-returnn/PKG-INFO,sha256=PZOQvfJJKkUgAsvh_nvFeAdQOFCWpBuj2T4euwap8VA,5215
+returnn/PKG-INFO,sha256=GVal7eVN_obo9mfdhPK2WvH2MzSm51cFZJChHEsF2XU,5214
 returnn/__init__.py,sha256=biBtRsM0WZ406vShaeH-9WFoqJ8XwTbn6g0EeFJ7l8E,1012
 returnn/__main__.py,sha256=lHyZcu_0yc9f7Vf_Kfdy9PmeU0T76XVXnpalHi5WKro,31740
 returnn/__old_mod_loader__.py,sha256=nvsNY-xELdS_IPNkv66Q9Rmvg4dbGW0-EBRDcCmctos,7654
 returnn/__setup__.py,sha256=22kQn2fh11iPM0hLb2Fy5sLmoU1JGvmDxXRYuRgQkwU,4659
-returnn/_setup_info_generated.py,sha256=ukzF4nRM4yknegwGHq4ktCyLc7tP9fasq5bpzDq0Tvg,77
+returnn/_setup_info_generated.py,sha256=jTlsQFAqLqFgm0UJ0uWltcnLf69QwqOK0yV4Slt-2Is,77
 returnn/config.py,sha256=3tmKhB6FnQZaNdtcYsiB61JnEY--iZ2qmJ4yq0b6tE0,29140
 returnn/forward_iface.py,sha256=A_OJiaXsX4MlXQRzST86ylyxSUZbC402PQL1REcqHjM,911
 returnn/learning_rate_control.py,sha256=ZvWryAn_tv9DhV8sh1LV3eE34Yltl3On3mYZAG4hR9s,34684
@@ -154,7 +154,7 @@ returnn/sprint/extern_interface.py,sha256=l-v1X-Yg0UpTFe7Y3c4FwWOqpSNuv9Oy5EzqlK
 returnn/sprint/interface.py,sha256=1j5SB0V8hSW8A5song9ciZtcBnZoKKfNipk9ezOIMuA,36491
 returnn/tensor/README.md,sha256=X6BqcRLrPLPnwF9yR69uqIFrMnNluj9pBkOPHwNgzuo,501
 returnn/tensor/__init__.py,sha256=on6j5PEOQpck50UcsR4nJzJSDmoVy34z1Oq4efv6Ax0,154
-returnn/tensor/_dim_extra.py,sha256=VN7Smn1Q0Y0DO7GSPM-aJUhp_jy5pzSMJbPkCk6JnqY,123448
+returnn/tensor/_dim_extra.py,sha256=rwtDR5WRS8wqgKj4WkPaWtaKa8UJYTrS76ZhX0W5bP4,115580
 returnn/tensor/_tensor_extra.py,sha256=gbSl6HMtn8WFYloanew_RaNNwx3eCpnKv3UfCkntJiQ,164923
 returnn/tensor/_tensor_mixin_base.py,sha256=H5z86I0NejxrSgMH1c5oXQzBqS6L9HpvP4y7oegBaSc,643
 returnn/tensor/_tensor_op_overloads.py,sha256=HklwuTBjy7mH_665VKaCUdu-oC3aa7Uz1ZQiCz4jeZc,5448
@@ -227,7 +227,7 @@ returnn/torch/util/README.md,sha256=AW-6ueWhgcwDcm57md6sm227QXNkvLnlRLwaH7NlS-w,
 returnn/torch/util/__init__.py,sha256=AOXYUjzPm0XrzFJCPAXo9Jj_FvqD1XH3FfKtho80Vl8,26
 returnn/torch/util/array_.py,sha256=ell3VZvn01SLtF9Pw2fvPzFNO-XDQ7tSB9VCrVSKmSA,2556
 returnn/torch/util/debug_inf_nan.py,sha256=fmzSSTJJyLf7i5yDWRHLeDI0gxvadeqLE8RxMuSHx_4,6398
-returnn/torch/util/diagnose_gpu.py,sha256=PYMmSk7iQ-jC3RXKKNXlYx1Q744C0LXqz0SB6ympwQg,5844
+returnn/torch/util/diagnose_gpu.py,sha256=_yswLmwR8Q2rCsv2jI5FUQNBT__453jBmiWYwazdu20,6808
 returnn/torch/util/exception_helper.py,sha256=_SqxTD5F-GDY2eR4uRALyUTJwt0ytcbJGB_w38RJMBA,4320
 returnn/torch/util/gradient_checkpoint.py,sha256=iLy-FB65DC8O6LxzmMvFjnSdpIVpko87ppIvRKAbtpQ,27995
 returnn/torch/util/module.py,sha256=MXHIrF9Isu575DDJIa81212ULKwdqu1oOLxDVZecVSk,1693
@@ -253,8 +253,8 @@ returnn/util/sig_proc.py,sha256=Tjz0VOAVyqu2qDCF5HZ1JjALjcFsHcNkcd96WgZeKfE,7265
 returnn/util/task_system.py,sha256=y4sMVXQ25Qd2z0rx03uOlXlkE-jbCYC1Sjfn-XlraVU,26003
 returnn/util/train_proc_manager.py,sha256=Pjht28k6uz6BNQ47uW6Gf880iyq5q4wx7P_K2tmoAM8,3266
 returnn/util/watch_memory.py,sha256=BR5P2kvBN6UI81cE0_1WAA6Hd1SByLbBaiDxvLhPOew,4213
-returnn-1.20250830.114445.dist-info/LICENSE,sha256=ywBD_U2aD4vpuoIgNAsjIGBYydl0tVKll3De0Z8s77c,11041
-returnn-1.20250830.114445.dist-info/METADATA,sha256=PZOQvfJJKkUgAsvh_nvFeAdQOFCWpBuj2T4euwap8VA,5215
-returnn-1.20250830.114445.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-returnn-1.20250830.114445.dist-info/top_level.txt,sha256=Lsn4WZc5Pbfk0-xDQOgnFCxOoqxL4CyeM3N1TFbJncw,8
-returnn-1.20250830.114445.dist-info/RECORD,,
+returnn-1.20250902.10950.dist-info/LICENSE,sha256=ywBD_U2aD4vpuoIgNAsjIGBYydl0tVKll3De0Z8s77c,11041
+returnn-1.20250902.10950.dist-info/METADATA,sha256=GVal7eVN_obo9mfdhPK2WvH2MzSm51cFZJChHEsF2XU,5214
+returnn-1.20250902.10950.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+returnn-1.20250902.10950.dist-info/top_level.txt,sha256=Lsn4WZc5Pbfk0-xDQOgnFCxOoqxL4CyeM3N1TFbJncw,8
+returnn-1.20250902.10950.dist-info/RECORD,,