returnn 1.20250122.134518__tar.gz → 1.20250123.173545__tar.gz

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

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

returnn-1.20250123.173545/_setup_info_generated.py

@@ -0,0 +1,2 @@
+version = '1.20250123.173545'
+long_version = '1.20250123.173545+git.5dab449'

{returnn-1.20250122.134518 → returnn-1.20250123.173545}/returnn/config.py

@@ -7,13 +7,16 @@ from __future__ import annotations
 __author__ = "Patrick Doetsch"
 __credits__ = ["Patrick Doetsch", "Paul Voigtlaender"]
 
-from typing import Optional, Any, Dict, List
+from typing import TypeVar, Type, Optional, Union, Any, Dict, List, Sequence, Tuple
 import contextlib
 import sys
 import os
 import types as _types
 
 
+T = TypeVar("T")
+
+
 class Config:
     """
     Reads in some config file, and provides access to the key/value items.
@@ -140,11 +143,10 @@ class Config:
             self.add_line(key=line[0], value=line[1])
 
     @classmethod
-    def get_config_file_type(cls, f):
+    def get_config_file_type(cls, f: str) -> str:
         """
-        :param str f: file path
+        :param f: file path
         :return: "py", "js" or "txt"
-        :rtype: str
         """
         with open(f, "r") as f:
             start = f.read(3)
@@ -154,9 +156,9 @@ class Config:
             return "js"
         return "txt"
 
-    def parse_cmd_args(self, args):
+    def parse_cmd_args(self, args: Sequence[str]):
         """
-        :param list[str]|tuple[str] args:
+        :param args:
         """
         from optparse import OptionParser
 
@@ -262,11 +264,12 @@ class Config:
                 value = value[1:]  # otherwise we never could specify things like "++threshold -0.1"
             self.add_line(key=key[2:], value=value)
 
-    def add_line(self, key, value):
+    def add_line(self, key: str, value: str):
         """
         Adds one specific configuration (key,value) pair to the inner set of parameters
-        :type key: str
-        :type value: str
+
+        :param key:
+        :param value:
         """
         if key in self.typed_dict:
             # This is a special case. We overwrite a config value which was typed before.
@@ -300,69 +303,65 @@ class Config:
         else:
             self.dict[key] = value
 
-    def has(self, key):
+    def has(self, key: str) -> bool:
         """
         Returns whether the given key is present in the inner set of parameters
-        :type key: string
-        :rtype: boolean
-        :returns True if and only if the given key is in the inner set of parameters
+
+        :param key:
+        :returns: True if and only if the given key is in the inner set of parameters
         """
         if key in self.typed_dict:
             return True
         return key in self.dict
 
-    def is_typed(self, key):
+    def is_typed(self, key: str) -> bool:
         """
-        :type key: string
-        :rtype: boolean
-        :returns True if and only if the value of the given key has a specified data type
+        :param key:
+        :returns: True if and only if the value of the given key has a specified data type
         """
         return key in self.typed_dict
 
-    def is_true(self, key, default=False):
+    def is_true(self, key: str, default: bool = False) -> bool:
         """
-        :param str key:
-        :param bool default:
+        :param key:
+        :param default:
         :return: bool(value) if it is set or default
-        :rtype: bool
         """
         if self.is_typed(key):
             return bool(self.typed_dict[key])
         return self.bool(key, default=default)
 
-    def is_of_type(self, key, types):
+    def is_of_type(self, key: str, types: Union[type, Tuple[type, ...]]) -> bool:
         """
-        :param str key:
-        :param type|tuple[type] types: for isinstance() check
+        :param key:
+        :param types: for isinstance() check
         :return: whether is_typed(key) is True and isinstance(value, types) is True
-        :rtype: bool
         """
         if key in self.typed_dict:
             return isinstance(self.typed_dict[key], types)
         return False
 
-    def get_of_type(self, key, types, default=None):
+    def get_of_type(self, key: str, types: Union[type, Tuple[type, ...], Type[T]], default: Optional[T] = None) -> T:
         """
         :param str key:
-        :param type|list[type]|T types: for isinstance() check
-        :param T|None default:
+        :param types: for isinstance() check
+        :param default:
         :return: if is_of_type(key, types) is True, returns the value, otherwise default
-        :rtype: T
         """
         if self.is_of_type(key, types):
             return self.typed_dict[key]
         return default
 
-    def set(self, key, value):
+    def set(self, key: str, value: Any):
         """
-        :type key: str
-        :type value: list[str] | str | int | float | bool | dict | None
+        :param key:
+        :param value:
         """
         self.typed_dict[key] = value
 
-    def update(self, dikt):
+    def update(self, dikt: Dict[str, Any]):
         """
-        :type dikt: dict
+        :param dikt: dict
         """
         for key, value in dikt.items():
             self.set(key, value)
@@ -383,13 +382,12 @@ class Config:
 
         setattr(self, "value", wrapped_value_func)
 
-    def value(self, key, default, index=None, list_join_str=","):
+    def value(self, key: str, default: T, index: Optional[int] = None, list_join_str: str = ",") -> Union[T, str]:
         """
-        :type key: str
-        :type default: T
-        :type index: int | None
-        :param str list_join_str:
-        :rtype: str | T
+        :param key:
+        :param default:
+        :param index:
+        :param list_join_str:
         """
         if key in self.typed_dict:
             ls = self.typed_dict[key]
@@ -410,12 +408,11 @@ class Config:
                 return ls[index]
         return default
 
-    def typed_value(self, key, default=None, index=None):
+    def typed_value(self, key: str, default: Optional[T] = None, index: Optional[int] = None) -> Union[T, Any]:
         """
-        :type key: str
-        :type default: T
-        :type index: int | None
-        :rtype: T | typing.Any
+        :param key:
+        :param default:
+        :param index:
         """
         value = self.typed_dict.get(key, default)
         if index is not None:
@@ -426,23 +423,22 @@ class Config:
                 assert index == 0
         return value
 
-    def opt_typed_value(self, key, default=None):
+    def opt_typed_value(self, key: str, default: Optional[T] = None) -> Union[T, Any, str]:
         """
-        :param str key:
-        :param T|None default:
-        :rtype: T|object|str|None
+        :param key:
+        :param default:
         """
         if key in self.typed_dict:
             return self.typed_dict[key]
         return self.value(key, default)
 
-    def int(self, key, default, index=0):
+    def int(self, key: str, default: T, index: int = 0) -> Union[int, T]:
         """
         Parses the value of the given key as integer, returning default if not existent
-        :type key: str
-        :type default: T
-        :type index: int
-        :rtype: int | T
+
+        :param key:
+        :param default:
+        :param index:
         """
         if key in self.typed_dict:
             value = self.typed_value(key, default=default, index=index)
@@ -453,13 +449,13 @@ class Config:
             return int(self.value(key, default, index))
         return default
 
-    def bool(self, key, default, index=0):
+    def bool(self, key: str, default: T, index: int = 0) -> Union[bool, T]:
         """
         Parses the value of the given key as boolean, returning default if not existent
-        :type key: str
-        :type default: T
-        :type index: int
-        :rtype: bool | T
+
+        :param key:
+        :param default:
+        :param index:
         """
         if key in self.typed_dict:
             value = self.typed_value(key, default=default, index=index)
@@ -477,13 +473,12 @@ class Config:
 
         return to_bool(v)
 
-    def bool_or_other(self, key, default=None, index=0):
+    def bool_or_other(self, key: str, default: Optional[T] = None, index: int = 0) -> Union[bool, T, Any]:
         """
-        :param str key:
-        :param T default:
-        :param int index:
+        :param key:
+        :param default:
+        :param index:
         :return: if we have typed value, just as-is. otherwise try to convert to bool. or default if not there.
-        :rtype: bool|T|object
         """
         if key in self.typed_dict:
             return self.typed_value(key, default=default, index=index)
@@ -499,13 +494,13 @@ class Config:
         except ValueError:
             return v
 
-    def float(self, key, default, index=0):
+    def float(self, key: str, default: T, index: int = 0) -> Union[float, T]:
         """
         Parses the value of the given key as float, returning default if not existent
-        :type key: str
-        :type default: T
-        :type index: int
-        :rtype: float | T
+
+        :param key:
+        :param default:
+        :param index:
         """
         if key in self.typed_dict:
             value = self.typed_value(key, default=default, index=index)
@@ -519,11 +514,10 @@ class Config:
             assert isinstance(value, (int, float))
         return value
 
-    def list(self, key, default=None):
+    def list(self, key: str, default: Optional[T] = None) -> Union[List[str], T]:
         """
-        :type key: str
-        :type default: T
-        :rtype: list[str] | T
+        :param key:
+        :param default:
         """
         if default is None:
             default = []
@@ -538,11 +532,10 @@ class Config:
             return default
         return self.dict[key]
 
-    def int_list(self, key, default=None):
+    def int_list(self, key: str, default: Optional[T] = None) -> Union[List[int], T]:
         """
-        :type key: str
-        :type default: T
-        :rtype: list[int] | T
+        :param key:
+        :param default:
         """
         if default is None:
             default = []
@@ -557,11 +550,10 @@ class Config:
             return list(value)
         return [int(x) for x in self.list(key, default)]
 
-    def float_list(self, key, default=None):
+    def float_list(self, key: str, default: Optional[T] = None) -> Union[List[float], T]:
         """
-        :type key: str
-        :type default: T
-        :rtype: list[float] | T
+        :param key:
+        :param default:
         """
         if default is None:
             default = []
@@ -576,11 +568,10 @@ class Config:
             return list(value)
         return [float(x) for x in self.list(key, default)]
 
-    def int_pair(self, key, default=None):
+    def int_pair(self, key: str, default: Optional[Tuple[int, int]] = None) -> Tuple[int, int]:
         """
-        :param str key:
-        :param (int,int)|None default:
-        :rtype: (int,int)
+        :param key:
+        :param default:
         """
         if default is None:
             default = (0, 0)

{returnn-1.20250122.134518 → returnn-1.20250123.173545}/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.20250123.173545}/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.20250123.173545}/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.20250123.173545}/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.20250123.173545}/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.20250123.173545}/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.20250123.173545}/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(