returnn 1.20250122.223647__tar.gz → 1.20250123.223321__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: returnn
-Version: 1.20250122.223647
+Version: 1.20250123.223321
 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.223321/_setup_info_generated.py

@@ -0,0 +1,2 @@
+version = '1.20250123.223321'
+long_version = '1.20250123.223321+git.eb6d734'

{returnn-1.20250122.223647 → returnn-1.20250123.223321}/demos/demo-iter-dataset.py

@@ -63,7 +63,6 @@ def init(config_filename, command_line_options):
     :param list[str] command_line_options:
     """
     rnn.init_better_exchook()
-    rnn.init_thread_join_hack()
     rnn.init_config(config_filename, command_line_options)
     global config
     config = rnn.config

{returnn-1.20250122.223647 → returnn-1.20250123.223321}/returnn/__main__.py

@@ -36,6 +36,7 @@ from returnn.util.basic import BackendEngine, BehaviorVersion
 # noinspection PyUnresolvedReferences
 from returnn.util.debug import init_ipython_kernel, init_better_exchook, init_faulthandler, debug_shell
 
+# Some external scripts import those functions from here, thus keep this here.
 # noinspection PyUnresolvedReferences
 from returnn.util.basic import init_thread_join_hack, describe_returnn_version
 
@@ -454,7 +455,6 @@ def init(config_filename=None, command_line_options=(), config_updates=None, ext
     """
     with util.ReportImportedDevModules(description="RETURNN init"):
         debug_util.init_better_exchook()
-        util.init_thread_join_hack()
         init_config(
             config_filename=config_filename, command_line_options=command_line_options, extra_updates=config_updates
         )

{returnn-1.20250122.223647 → returnn-1.20250123.223321}/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.223647 → returnn-1.20250123.223321}/returnn/datasets/audio.py

@@ -13,7 +13,6 @@ from .cached2 import CachedDataset2
 from .util.feature_extraction import ExtractAudioFeatures
 from .util.vocabulary import Vocabulary
 from .util.strings import str_to_numpy_array
-from returnn.util.basic import PY3
 
 
 class OggZipDataset(CachedDataset2):
@@ -553,11 +552,8 @@ class OggZipDataset(CachedDataset2):
             features["classes"] = numpy.array(targets, dtype="int32")
         raw_txt = str_to_numpy_array(txt)
         orth = txt.encode("utf8")
-        if PY3:
-            assert isinstance(orth, bytes)
-            orth = list(orth)
-        else:
-            orth = list(map(ord, orth))
+        assert isinstance(orth, bytes)
+        orth = list(orth)
         orth = numpy.array(orth, dtype="uint8")
         return DatasetSeq(
             features={**features, "raw": raw_txt, "orth": orth},

{returnn-1.20250122.223647 → returnn-1.20250123.223321}/returnn/datasets/hdf.py

@@ -3,8 +3,9 @@ Provides :class:`HDFDataset`.
 """
 
 from __future__ import annotations
-import bisect
+from typing import Union
 import typing
+import bisect
 import collections
 import gc
 import h5py
@@ -67,17 +68,8 @@ class HDFDataset(CachedDataset):
         del self.file_seq_start[:]
 
     @staticmethod
-    def _decode(s):
-        """
-        :param str|bytes|unicode s:
-        :rtype: str
-        """
-        from returnn.util.basic import unicode, PY3
-
-        if not PY3 and isinstance(s, unicode):
-            s = s.encode("utf8")
-            assert isinstance(s, str)  # Python 2
-        if not isinstance(s, str):  # bytes (Python 3)
+    def _decode(s: Union[str, bytes]) -> str:
+        if isinstance(s, bytes):
             s = s.decode("utf-8")
         s = s.split("\0")[0]
         return s
@@ -1431,7 +1423,7 @@ class HDFDatasetWriter:
         :param int|float end_seq:
         :param bool use_progress_bar:
         """
-        from returnn.util.basic import NumbersDict, human_size, progress_bar_with_time, try_run, PY3
+        from returnn.util.basic import NumbersDict, human_size, progress_bar_with_time, try_run
 
         hdf_dataset = self.file
 
@@ -1544,8 +1536,7 @@ class HDFDatasetWriter:
                 hdf_dataset["targets/size"].attrs[hdf_data_key_map[data_key]] = dataset.num_outputs[data_key]
             if data_key in dataset.labels:
                 labels = dataset.labels[data_key]
-                if PY3:
-                    labels = [label.encode("utf8") for label in labels]
+                labels = [label.encode("utf8") for label in labels]
                 assert len(labels) == dataset.num_outputs[data_key][0]
             else:
                 labels = ["%s-class-%i" % (data_key, i) for i in range(dataset.get_data_dim(data_key))]

{returnn-1.20250122.223647 → returnn-1.20250123.223321}/returnn/datasets/sprint.py

@@ -25,7 +25,7 @@ from returnn.datasets.basic import Dataset, DatasetSeq
 from .cached2 import CachedDataset2
 from returnn.log import log
 from returnn.util.task_system import numpy_copy_and_set_unused
-from returnn.util.basic import eval_shell_str, interrupt_main, unicode, PY3, close_all_fds_except
+from returnn.util.basic import eval_shell_str, interrupt_main, unicode, close_all_fds_except
 import returnn.util.basic as util
 
 
@@ -442,11 +442,8 @@ class SprintDatasetBase(Dataset):
             if isinstance(v, unicode):
                 v = v.encode("utf8")
             if isinstance(v, (str, bytes)):
-                if PY3:
-                    assert isinstance(v, bytes)
-                    v = list(v)
-                else:
-                    v = list(map(ord, v))
+                assert isinstance(v, bytes)
+                v = list(v)
                 v = numpy.array(v, dtype="uint8")
                 targets[key] = v
                 if self.str_add_final_zero:

{returnn-1.20250122.223647 → returnn-1.20250123.223321}/returnn/log.py

@@ -14,8 +14,6 @@ import contextlib
 import string
 import typing
 
-PY3 = sys.version_info[0] >= 3
-
 
 class Stream:
     """

{returnn-1.20250122.223647 → returnn-1.20250123.223321}/returnn/sprint/control.py

@@ -47,7 +47,6 @@ print("RETURNN SprintControl[pid %i] Python module load" % os.getpid())
 
 rnn.init_better_exchook()
 debug.init_faulthandler(sigusr1_chain=True)  # Sprint also handles SIGUSR1.
-rnn.init_thread_join_hack()
 
 
 # Start Sprint PythonControl interface. {

{returnn-1.20250122.223647 → returnn-1.20250123.223321}/returnn/sprint/interface.py

@@ -712,7 +712,6 @@ def _init_base(configfile=None, target_mode=None, epoch=None, sprint_opts=None):
         # Some subset of what we do in rnn.init().
 
         rnn.init_better_exchook()
-        rnn.init_thread_join_hack()
 
         if configfile is None:
             configfile = DefaultSprintCrnnConfig

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

@@ -26,6 +26,7 @@ class _TensorOpOverloadsMixin(_TensorMixinBase):
         log.print_deprecation_warning(
             f"{self} __bool__: Using a Tensor in a boolean context is deprecated.", behavior_version=22
         )
+        return True
 
     # --- comparisons
 

{returnn-1.20250122.223647 → returnn-1.20250123.223321}/returnn/tf/layers/basic.py

@@ -11,7 +11,7 @@ import contextlib
 from returnn.tensor import Tensor, Dim
 import returnn.tf.compat as tf_compat
 import returnn.tf.util.basic as tf_util
-from returnn.util.basic import unicode, NotSpecified
+from returnn.util.basic import NotSpecified
 from returnn.tf.util.data import Data, SearchBeam, FeatureDim, SpatialDim
 from returnn.tf.util.basic import OutputWithActivation, dimshuffle, swapaxes
 from returnn.log import log
@@ -13407,7 +13407,7 @@ class ViaLayerLoss(Loss):
                 error_signal = where_bc(seq_mask_bc, error_signal, 0.0)
             if self.loss_wrt_to_act_in:
                 assert self.output_with_activation, "activation unknown, via %r" % self.output
-                if isinstance(self.loss_wrt_to_act_in, (str, unicode)):
+                if isinstance(self.loss_wrt_to_act_in, str):
                     from returnn.tf.util.basic import get_activation_function
 
                     assert self.output_with_activation.act_func is get_activation_function(self.loss_wrt_to_act_in)

{returnn-1.20250122.223647 → returnn-1.20250123.223321}/returnn/tf/util/basic.py

@@ -352,15 +352,16 @@ class OutputWithActivation:
         return safe_log(self.y)
 
 
-def variable_scalar_summaries_dict(x, name=None):
+def variable_scalar_summaries_dict(
+    x: Union[tf.Tensor, tf.Variable], name: Optional[str] = None
+) -> Dict[str, tf.Tensor]:
     """
     Collects all interesting information about `x`, such as min/max/mean, etc. (all scalars).
     This is used by :func:`variable_summaries`.
 
-    :param tf.Tensor|tf.Variable x:
-    :param str name:
-    :return: dicth with key -> scalar info, e.g. with "%s_mean" % name -> tf.reduce_mean(x)
-    :rtype: dict[str,tf.Tensor]
+    :param x:
+    :param name:
+    :return: dict with key -> scalar info, e.g. with "%s_mean" % name -> tf.reduce_mean(x)
     """
     if x.dtype == tf.string:
         return {}
@@ -1025,7 +1026,7 @@ def setup_tf_thread_pools(num_threads=None, log_file=None, tf_session_opts=None)
 
     :param int num_threads: used for both intra and inter parallelism thread pools
     :param stream|None log_file:
-    :param dict[str] tf_session_opts:
+    :param dict[str,typing.Any] tf_session_opts:
     """
     global _setup_tf_thread_pools_called_once
     if _setup_tf_thread_pools_called_once:
@@ -1056,12 +1057,12 @@ def setup_tf_thread_pools(num_threads=None, log_file=None, tf_session_opts=None)
         session.close()
 
 
-def check_initial_tf_thread_pool_init(tf_session_opts=None):
+def check_initial_tf_thread_pool_init(tf_session_opts: Dict[str, Any] = None):
     """
     Makes sure that the TF thread pools are initialized with the requested settings.
     You probably want to call this very early.
 
-    :param dict[str]|None tf_session_opts:
+    :param tf_session_opts:
     """
     if not _setup_tf_thread_pools_called_once:
         from returnn.util.basic import try_get_caller_name
@@ -1184,7 +1185,7 @@ def print_available_devices(tf_session_opts=None, file=None):
     Note that a call to this will trigger the internal TF thread pool inits,
     so you should call :func:`setup_tf_thread_pools` first.
 
-    :param dict[str]|None tf_session_opts: if given, will init a temp Session with these opts
+    :param dict[str,typing.Any]|None tf_session_opts: if given, will init a temp Session with these opts
     :param typing.TextIO|None file: file stream for print statements, defaults to sys.stdout
     """
     if file is None: