returnn 1.20250123.173545__tar.gz → 1.20250123.223321__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: returnn
-Version: 1.20250123.173545
+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.20250123.173545 → 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.20250123.173545 → 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.20250123.173545 → 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.20250123.173545 → 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.20250123.173545 → 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.20250123.173545 → 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.20250123.173545 → 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.20250123.173545 → 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.20250123.173545 → 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.20250123.173545 → returnn-1.20250123.223321}/returnn/util/basic.py

@@ -37,8 +37,6 @@ import builtins
 
 from .native_code_compiler import NativeCodeCompiler
 
-PY3 = sys.version_info[0] >= 3
-
 unicode = str
 long = int
 # noinspection PyShadowingBuiltins
@@ -392,8 +390,7 @@ def sys_cmd_out_lines(s):
         env=dict(os.environ, LANG="en_US.UTF-8", LC_ALL="en_US.UTF-8"),
     )
     stdout = p.communicate()[0]
-    if PY3:
-        stdout = stdout.decode("utf8")
+    stdout = stdout.decode("utf8")
     result = [line.strip() for line in stdout.split("\n")[:-1]]
     p.stdout.close()
     if p.returncode != 0:
@@ -1416,113 +1413,10 @@ def init_thread_join_hack():
     if _thread_join_hack_installed:  # don't install twice
         return
     _thread_join_hack_installed = True
-    if PY3:
-        # These monkey patches are not necessary anymore. Nothing blocks signals anymore in Python 3.
-        # https://github.com/albertz/playground/blob/master/thread-join-block.py
-        # https://github.com/albertz/playground/blob/master/cond-wait-block.py
-        return
-    main_thread = threading.current_thread()
-    # noinspection PyUnresolvedReferences,PyProtectedMember
-    assert isinstance(main_thread, threading._MainThread)
-    main_thread_id = thread.get_ident()
-
-    # Patch Thread.join().
-    join_orig = threading.Thread.join
-
-    def join_hacked(thread_obj, timeout=None):
-        """
-        :type thread_obj: threading.Thread
-        :type timeout: float|None
-        :return: always None
-        """
-        if thread.get_ident() == main_thread_id and timeout is None:
-            # This is a HACK for Thread.join() if we are in the main thread.
-            # In that case, a Thread.join(timeout=None) would hang and even not respond to signals
-            # because signals will get delivered to other threads and Python would forward
-            # them for delayed handling to the main thread which hangs.
-            # See CPython signalmodule.c.
-            # Currently the best solution I can think of:
-            while thread_obj.is_alive():
-                join_orig(thread_obj, timeout=0.1)
-        elif thread.get_ident() == main_thread_id and timeout > 0.1:
-            # Limit the timeout. This should not matter for the underlying code.
-            join_orig(thread_obj, timeout=0.1)
-        else:
-            # In all other cases, we can use the original.
-            join_orig(thread_obj, timeout=timeout)
-
-    threading.Thread.join = join_hacked
-
-    # Mostly the same for Condition.wait().
-    if PY3:
-        # https://youtrack.jetbrains.com/issue/PY-34983
-        # noinspection PyPep8Naming
-        Condition = threading.Condition
-    else:
-        # noinspection PyUnresolvedReferences,PyPep8Naming,PyProtectedMember
-        Condition = threading._Condition
-    cond_wait_orig = Condition.wait
-
-    # noinspection PyUnusedLocal
-    def cond_wait_hacked(cond, timeout=None, *args):
-        """
-        :param Condition cond:
-        :param float|None timeout:
-        :param args:
-        :rtype: bool
-        """
-        if thread.get_ident() == main_thread_id:
-            if timeout is None:
-                # Use a timeout anyway. This should not matter for the underlying code.
-                return cond_wait_orig(cond, timeout=0.1)  # noqa  # https://youtrack.jetbrains.com/issue/PY-43915
-            # There is some code (e.g. multiprocessing.pool) which relies on that
-            # we respect the real specified timeout.
-            # However, we cannot do multiple repeated calls to cond_wait_orig as we might miss the condition notify.
-            # But in some Python versions, the underlying cond_wait_orig will anyway also use sleep.
-            return cond_wait_orig(cond, timeout=timeout)  # noqa
-        else:
-            return cond_wait_orig(cond, timeout=timeout)  # noqa
-
-    Condition.wait = cond_wait_hacked
-
-    # And the same for Lock.acquire, very similar to Condition.wait.
-    # However: can't set attributes of built-in/extension type 'thread.lock'.
-    # We could wrap the whole threading.Lock, but that is too annoying for me now...
-    # noinspection PyPep8Naming
-    Lock = None
-    if Lock:
-        lock_acquire_orig = Lock.acquire  # noqa
-
-        # Note: timeout argument was introduced in Python 3.
-        def lock_acquire_hacked(lock, blocking=True, timeout=-1):
-            """
-            :param threading.Lock lock:
-            :param bool blocking:
-            :param float timeout:
-            :rtype: bool
-            """
-            if not blocking:
-                return lock_acquire_orig(lock, blocking=False)  # no timeout if not blocking
-            # Everything is blocking now.
-            if thread.get_ident() == main_thread_id:
-                if timeout is None or timeout < 0:  # blocking without timeout
-                    if PY3:
-                        while not lock_acquire_orig(lock, blocking=True, timeout=0.1):
-                            pass
-                        return True
-                    else:  # Python 2. cannot use timeout
-                        while not lock_acquire_orig(lock, blocking=False):
-                            time.sleep(0.1)
-                        return True
-                else:  # timeout is set. (Can only be with Python 3.)
-                    # Use a capped timeout. This should not matter for the underlying code.
-                    return lock_acquire_orig(lock, blocking=True, timeout=min(timeout, 0.1))
-            # Fallback to default.
-            if PY3:
-                return lock_acquire_orig(lock, blocking=True, timeout=timeout)
-            return lock_acquire_orig(lock, blocking=True)
-
-        Lock.acquire = lock_acquire_hacked
+    # These monkey patches are not necessary anymore. Nothing blocks signals anymore in Python 3.
+    # https://github.com/albertz/playground/blob/master/thread-join-block.py
+    # https://github.com/albertz/playground/blob/master/cond-wait-block.py
+    log.print_deprecation_warning("init_thread_join_hack: not necessary anymore since Python 3 (does nothing)")
 
 
 def start_daemon_thread(target, args=()):
@@ -1944,25 +1838,6 @@ def json_remove_comments(string, strip_space=True):
     return "".join(new_str)
 
 
-def _py2_unicode_to_str_recursive(s):
-    """
-    This is supposed to be run with Python 2.
-    Also see :func:`as_str` and :func:`py2_utf8_str_to_unicode`.
-
-    :param str|unicode s: or any recursive structure such as dict, list, tuple
-    :return: Python 2 str (is like Python 3 UTF-8 formatted bytes)
-    :rtype: str
-    """
-    if isinstance(s, dict):
-        return {_py2_unicode_to_str_recursive(key): _py2_unicode_to_str_recursive(value) for key, value in s.items()}
-    elif isinstance(s, (list, tuple)):
-        return make_seq_of_type(type(s), [_py2_unicode_to_str_recursive(element) for element in s])
-    elif isinstance(s, unicode):
-        return s.encode("utf-8")  # Python 2 str, Python 3 bytes
-    else:
-        return s
-
-
 def load_json(filename: Optional[str] = None, content: Optional[str] = None) -> Dict[str, Any]:
     """
     :param filename:
@@ -1980,8 +1855,6 @@ def load_json(filename: Optional[str] = None, content: Optional[str] = None) ->
         json_content = json.loads(content)
     except ValueError as e:
         raise Exception("config looks like JSON but invalid json content, %r" % e)
-    if not PY3:
-        json_content = _py2_unicode_to_str_recursive(json_content)
     return json_content
 
 
@@ -2425,11 +2298,7 @@ def getargspec(func):
     :param func:
     :return: FullArgSpec
     """
-    if PY3:
-        return inspect.getfullargspec(func)
-    else:
-        # noinspection PyDeprecation
-        return inspect.getargspec(func)
+    return inspect.getfullargspec(func)
 
 
 def collect_mandatory_class_init_kwargs(cls):
@@ -2685,28 +2554,6 @@ def as_str(s):
     assert False, "unknown type %s" % type(s)
 
 
-def py2_utf8_str_to_unicode(s):
-    """
-    :param str s: e.g. the string literal "äöü" in Python 3 is correct, but in Python 2 it should have been u"äöü",
-      but just using "äöü" will actually be the raw utf8 byte sequence.
-      This can happen when you eval() some string.
-      We assume that you are using Python 2, and got the string (not unicode object) "äöü", or maybe "abc".
-      Also see :func:`_py2_unicode_to_str_recursive` and :func:`as_str`.
-    :return: if it is indeed unicode, it will return the unicode object, otherwise it keeps the string
-    :rtype: str|unicode
-    """
-    assert not PY3
-    assert isinstance(s, str)
-    try:
-        # noinspection PyUnresolvedReferences
-        s.decode("ascii")
-        return s
-    except UnicodeDecodeError:
-        pass
-    # noinspection PyUnresolvedReferences
-    return s.decode("utf8")
-
-
 def unicode_to_str(s):
     """
     The behavior is different depending on Python 2 or Python 3. In all cases, the returned type is a str object.
@@ -2722,12 +2569,9 @@ def unicode_to_str(s):
     :param str|unicode|bytes s:
     :rtype: str
     """
-    if PY3 and isinstance(s, bytes):
+    if isinstance(s, bytes):
         s = s.decode("utf8")
         assert isinstance(s, str)
-    if not PY3 and isinstance(s, unicode):
-        s = s.encode("utf8")
-        assert isinstance(s, str)
     assert isinstance(s, str)
     return s
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: returnn
-Version: 1.20250123.173545
+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.173545 → returnn-1.20250123.223321}/tests/_setup_test_env.py

@@ -42,8 +42,6 @@ def setup():
 
     import returnn.util.basic as util
 
-    util.init_thread_join_hack()
-
     # noinspection PyProtectedMember
     util.BehaviorVersion.set_min_behavior_version(util.BehaviorVersion._latest_behavior_version)
 

{returnn-1.20250123.173545 → returnn-1.20250123.223321}/tests/test_HDFDataset.py

@@ -290,11 +290,10 @@ def test_SimpleHDFWriter_small():
     for i, seq_len in enumerate(seq_lens):
         assert reader.seq_lens[i]["data"] == seq_len
 
-    if sys.version_info[0] >= 3:  # gzip.compress is >=PY3
-        print("raw content (gzipped):")
-        import gzip
+    print("raw content (gzipped):")
+    import gzip
 
-        print(repr(gzip.compress(open(fn, "rb").read())))
+    print(repr(gzip.compress(open(fn, "rb").read())))
 
 
 def test_SimpleHDFWriter_empty_extra():
@@ -354,8 +353,6 @@ def test_SimpleHDFWriter_empty_extra():
 
 
 def test_read_simple_hdf():
-    if sys.version_info[0] <= 2:  # gzip.decompress is >=PY3
-        raise unittest.SkipTest
     # n_dim, seq_lens, raw_gzipped is via test_SimpleHDFWriter_small
     n_dim = 3
     seq_lens = [2, 3]

{returnn-1.20250123.173545 → returnn-1.20250123.223321}/tests/test_Log.py

@@ -18,7 +18,6 @@ __my_dir__ = os.path.dirname(os.path.abspath(__file__))
 __base_dir__ = os.path.dirname(__my_dir__)
 __main_entry__ = __base_dir__ + "/rnn.py"
 py = sys.executable
-PY3 = sys.version_info[0] >= 3
 
 
 def build_env():
@@ -178,9 +177,7 @@ def test_StreamIO():
 
     buf.write("hello")
     print("buf: %r" % buf.getvalue())
-    if PY3:
-        # This behavior is not correct in Python 2.7. https://bugs.python.org/issue30250
-        assert buf.getvalue() == "\x00\x00\x00\x00\x00hello"  # zero-filled
+    assert buf.getvalue() == "\x00\x00\x00\x00\x00hello"  # zero-filled
     buf.truncate(0)
     buf.seek(0)
     print("buf: %r" % buf.getvalue())

{returnn-1.20250123.173545 → returnn-1.20250123.223321}/tests/test_TFNetworkLayer.py

@@ -11630,8 +11630,6 @@ def test_subnetwork_unused_output():
 
 def test_subnetwork_deep_stack():
     # https://github.com/rwth-i6/returnn/issues/993
-    if not util.PY3:
-        raise unittest.SkipTest("test case needs python 3")  # __qualname__, __func__, etc
     with make_scope() as session:
         import better_exchook
         import traceback

{returnn-1.20250123.173545 → returnn-1.20250123.223321}/tests/test_TFUtil.py

@@ -4133,8 +4133,6 @@ def test_softmax_cross_entropy_over_size_n_batch():
 
 
 def test_softmax_cross_entropy_over_size_n_batch_real():
-    if sys.version_info[0] <= 2:  # gzip.decompress is >=PY3
-        raise unittest.SkipTest
     import gzip
     import base64
 

{returnn-1.20250123.173545 → returnn-1.20250123.223321}/tests/test_TranslationDataset.py

@@ -12,11 +12,6 @@ import pickle
 import _setup_test_env  # noqa
 from returnn.util import better_exchook
 from returnn.datasets.lm import TranslationDataset, TranslationFactorsDataset
-from returnn.util.basic import init_thread_join_hack
-
-better_exchook.install()
-better_exchook.replace_traceback_format_tb()
-init_thread_join_hack()
 
 
 dummy_source_text = (

{returnn-1.20250123.173545 → returnn-1.20250123.223321}/tests/test_Util.py

@@ -496,14 +496,6 @@ def test_obj_diff_list_allowed_mapping():
     ]
 
 
-@unittest.skipIf(PY3, "only for Python 2")
-def test_py2_utf8_str_to_unicode():
-    assert py2_utf8_str_to_unicode("a") == "a"
-    assert type(py2_utf8_str_to_unicode("a")) is str
-    assert py2_utf8_str_to_unicode("äöü") == "äöü"
-    assert type(py2_utf8_str_to_unicode("äöü")) is unicode
-
-
 def test_CollectionReadCheckCovered():
     x = CollectionReadCheckCovered.from_bool_or_dict(True)
     assert x and x.truth_value

{returnn-1.20250123.173545 → returnn-1.20250123.223321}/tools/analyze-dataset-batches.py

@@ -144,7 +144,6 @@ def init(config_str, config_dataset, use_pretrain, epoch, verbosity):
     :param int verbosity:
     """
     rnn.init_better_exchook()
-    rnn.init_thread_join_hack()
     dataset_opts = None
     config_filename = None
     if config_str.strip().startswith("{"):

{returnn-1.20250123.173545 → returnn-1.20250123.223321}/tools/calculate-word-error-rate.py

@@ -158,7 +158,6 @@ def init(config_filename, log_verbosity):
     :param int log_verbosity:
     """
     rnn.init_better_exchook()
-    rnn.init_thread_join_hack()
     if config_filename:
         print("Using config file %r." % config_filename)
         assert os.path.exists(config_filename)

{returnn-1.20250123.173545 → returnn-1.20250123.223321}/tools/collect-orth-symbols.py

@@ -225,7 +225,6 @@ def collect_stats(options, iter_corpus):
 
 def init(config_filename=None):
     rnn.init_better_exchook()
-    rnn.init_thread_join_hack()
     if config_filename:
         rnn.init_config(config_filename, command_line_options=[])
         rnn.init_log()

{returnn-1.20250123.173545 → returnn-1.20250123.223321}/tools/collect-words.py

@@ -141,7 +141,6 @@ def init(config_filename=None):
     :param str config_filename:
     """
     rnn.init_better_exchook()
-    rnn.init_thread_join_hack()
     if config_filename:
         rnn.init_config(config_filename, command_line_options=[])
         rnn.init_log()

{returnn-1.20250123.173545 → returnn-1.20250123.223321}/tools/compile_native_op.py

@@ -29,7 +29,6 @@ def init(config_filename, log_verbosity):
     :param int log_verbosity:
     """
     rnn.init_better_exchook()
-    rnn.init_thread_join_hack()
     if config_filename:
         print("Using config file %r." % config_filename)
         assert os.path.exists(config_filename)

{returnn-1.20250123.173545 → returnn-1.20250123.223321}/tools/compile_tf_graph.py

@@ -44,7 +44,6 @@ def init(config_filename, log_verbosity, device):
     :param str device:
     """
     rnn.init_better_exchook()
-    rnn.init_thread_join_hack()
     print("Using config file %r." % config_filename)
     assert os.path.exists(config_filename)
     rnn.init_config(

{returnn-1.20250123.173545 → returnn-1.20250123.223321}/tools/debug-dump-search-scores.py

@@ -37,7 +37,6 @@ def init(config_filename, log_verbosity, remaining_args=()):
     :param list[str] remaining_args:
     """
     rnn.init_better_exchook()
-    rnn.init_thread_join_hack()
     print("Using config file %r." % config_filename)
     assert os.path.exists(config_filename)
     rnn.init_config(

{returnn-1.20250123.173545 → returnn-1.20250123.223321}/tools/dump-dataset-raw-strings.py

@@ -91,7 +91,6 @@ def init(config_filename, log_verbosity):
     :param int log_verbosity:
     """
     rnn.init_better_exchook()
-    rnn.init_thread_join_hack()
     if config_filename:
         print("Using config file %r." % config_filename)
         assert os.path.exists(config_filename)

{returnn-1.20250123.173545 → returnn-1.20250123.223321}/tools/dump-dataset.py

@@ -253,7 +253,6 @@ def init(options):
     """
     global dataset
     rnn.init_better_exchook()
-    rnn.init_thread_join_hack()
     dataset_dict = None
     config_filename = None
     config_str = options.returnn_config

{returnn-1.20250123.173545 → returnn-1.20250123.223321}/tools/hdf_dump.py

@@ -55,7 +55,6 @@ def init(config_filename, cmd_line_opts, dataset_config_str):
     :param str dataset_config_str: dataset via init_dataset_via_str()
     """
     rnn.init_better_exchook()
-    rnn.init_thread_join_hack()
     if config_filename:
         rnn.init_config(config_filename, cmd_line_opts)
         rnn.init_log()

{returnn-1.20250123.173545 → returnn-1.20250123.223321}/tools/torch_export_to_onnx.py

@@ -62,7 +62,6 @@ def init(config_filename: str, checkpoint: str, log_verbosity: int, device: str)
     """
     assert os.path.exists(checkpoint), "The specified checkpoint doesn't exist."
     rnn.init_better_exchook()
-    rnn.init_thread_join_hack()
     assert os.path.exists(config_filename), "The specified config doesn't exist."
     print("Using config file %r." % config_filename)
     rnn.init_config(

returnn-1.20250123.173545/_setup_info_generated.py

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