returnn 1.20241210.150216__tar.gz → 1.20241211.145755__tar.gz

{returnn-1.20241210.150216 → returnn-1.20241211.145755}/PKG-INFO

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

returnn-1.20241211.145755/_setup_info_generated.py

@@ -0,0 +1,2 @@
+version = '1.20241211.145755'
+long_version = '1.20241211.145755+git.4c6e245'

{returnn-1.20241210.150216 → returnn-1.20241211.145755}/returnn.egg-info/PKG-INFO

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

{returnn-1.20241210.150216 → returnn-1.20241211.145755}/tests/test_Config.py

@@ -1,7 +1,6 @@
 import sys
 import _setup_test_env  # noqa
 import unittest
-from nose.tools import assert_equal, assert_is_instance, assert_in, assert_greater, assert_true, assert_false
 from pprint import pprint
 from returnn.config import *
 from returnn.util import better_exchook
@@ -21,16 +20,16 @@ def test_old_format():
         )
     )
 
-    assert_true(config.has("num_inputs"))
-    assert_true(config.has("hidden_type"))
-    assert_equal(config.int("num_inputs", -1), 3)
-    assert_equal(config.value("hidden_type", "x"), "forward,lstm")
-    assert_equal(config.value("hidden_type", "x", index=0), "forward")
-    assert_equal(config.value("hidden_type", "x", index=1), "lstm")
-    assert_equal(config.list("hidden_type", ["x"]), ["forward", "lstm"])
+    assert config.has("num_inputs") is True
+    assert config.has("hidden_type") is True
+    assert config.int("num_inputs", -1) == 3
+    assert config.value("hidden_type", "x") == "forward,lstm"
+    assert config.value("hidden_type", "x", index=0) == "forward"
+    assert config.value("hidden_type", "x", index=1) == "lstm"
+    assert config.list("hidden_type", ["x"]) == ["forward", "lstm"]
 
-    assert_false(config.is_typed("num_inputs"))
-    assert_false(config.is_typed("hidden_type"))
+    assert config.is_typed("num_inputs") is False
+    assert config.is_typed("hidden_type") is False
 
 
 def test_json_format():
@@ -47,19 +46,19 @@ def test_json_format():
         )
     )
 
-    assert_true(config.has("num_inputs"))
-    assert_true(config.has("hidden_type"))
-    assert_equal(config.int("num_inputs", -1), 3)
-    assert_equal(config.value("hidden_type", "x"), "forward,lstm")
-    assert_equal(config.value("hidden_type", "x", index=0), "forward")
-    assert_equal(config.value("hidden_type", "x", index=1), "lstm")
-    assert_equal(config.list("hidden_type", ["x"]), ["forward", "lstm"])
+    assert config.has("num_inputs") is True
+    assert config.has("hidden_type") is True
+    assert config.int("num_inputs", -1) == 3
+    assert config.value("hidden_type", "x") == "forward,lstm"
+    assert config.value("hidden_type", "x", index=0) == "forward"
+    assert config.value("hidden_type", "x", index=1) == "lstm"
+    assert config.list("hidden_type", ["x"]) == ["forward", "lstm"]
 
-    assert_true(config.is_typed("num_inputs"))
-    assert_true(config.is_typed("hidden_type"))
-    assert_is_instance(config.typed_value("num_inputs"), int)
-    assert_is_instance(config.typed_value("hidden_type"), list)
-    assert_equal(config.typed_value("hidden_type"), ["forward", "lstm"])
+    assert config.is_typed("num_inputs") is True
+    assert config.is_typed("hidden_type") is True
+    assert isinstance(config.typed_value("num_inputs"), int)
+    assert isinstance(config.typed_value("hidden_type"), list)
+    assert config.typed_value("hidden_type") == ["forward", "lstm"]
 
 
 def test_py_config():
@@ -74,19 +73,19 @@ hidden_type = ["forward", "lstm"]
         )
     )
 
-    assert_true(config.has("num_inputs"))
-    assert_true(config.has("hidden_type"))
-    assert_equal(config.int("num_inputs", -1), 3)
-    assert_equal(config.value("hidden_type", "x"), "forward,lstm")
-    assert_equal(config.value("hidden_type", "x", index=0), "forward")
-    assert_equal(config.value("hidden_type", "x", index=1), "lstm")
-    assert_equal(config.list("hidden_type", ["x"]), ["forward", "lstm"])
+    assert config.has("num_inputs") is True
+    assert config.has("hidden_type") is True
+    assert config.int("num_inputs", -1) == 3
+    assert config.value("hidden_type", "x") == "forward,lstm"
+    assert config.value("hidden_type", "x", index=0) == "forward"
+    assert config.value("hidden_type", "x", index=1) == "lstm"
+    assert config.list("hidden_type", ["x"]) == ["forward", "lstm"]
 
-    assert_true(config.is_typed("num_inputs"))
-    assert_true(config.is_typed("hidden_type"))
-    assert_is_instance(config.typed_value("num_inputs"), int)
-    assert_is_instance(config.typed_value("hidden_type"), list)
-    assert_equal(config.typed_value("hidden_type"), ["forward", "lstm"])
+    assert config.is_typed("num_inputs") is True
+    assert config.is_typed("hidden_type") is True
+    assert isinstance(config.typed_value("num_inputs"), int)
+    assert isinstance(config.typed_value("hidden_type"), list)
+    assert config.typed_value("hidden_type") == ["forward", "lstm"]
 
 
 def test_rnn_init_config_py_global_var():
@@ -115,9 +114,9 @@ def test_func():
     assert rnn.config.has("task")
     assert rnn.config.has("test_value")
     assert rnn.config.has("test_func")
-    assert_equal(rnn.config.value("task", None), "search")
+    assert rnn.config.value("task", None) == "search"
     assert rnn.config.is_typed("test_value")
-    assert_equal(rnn.config.typed_value("test_value"), 42)
+    assert rnn.config.typed_value("test_value") == 42
     assert rnn.config.is_typed("test_func")
     # So far it's fine.
     # Now something a bit strange.
@@ -125,7 +124,7 @@ def test_func():
     assert rnn.config.is_typed("task")
     test_func = rnn.config.typed_dict["test_func"]
     assert callable(test_func)
-    assert_equal(test_func(), "search")
+    assert test_func() == "search"
 
 
 def test_rnn_init_config_py_cmd_type():
@@ -152,7 +151,7 @@ def test_func():
     assert rnn.config.is_typed("test_func")
     test_func = rnn.config.typed_dict["test_func"]
     assert callable(test_func)
-    assert_equal(test_func(), 0)
+    assert test_func() == 0
 
 
 def test_config_py_ext():
@@ -176,9 +175,9 @@ def test_func():
     assert config.is_typed("test_func")
     test_func = config.typed_dict["test_func"]
     assert callable(test_func)
-    assert_equal(test_func(), "train")
+    assert test_func() == "train"
     config.set("task", "search")
-    assert_equal(test_func(), "search")
+    assert test_func() == "search"
 
 
 def test_config_py_old_returnn_imports():

{returnn-1.20241210.150216 → returnn-1.20241211.145755}/tests/test_Dataset.py

@@ -10,7 +10,6 @@ import unittest
 import numpy
 import tempfile
 import contextlib
-from nose.tools import assert_equal, assert_is_instance, assert_in, assert_not_in, assert_true, assert_false
 from returnn.datasets.generating import Task12AXDataset, DummyDataset, DummyDatasetMultipleSequenceLength
 from returnn.engine.batch import Batch
 from returnn.datasets.basic import Dataset, DatasetSeq, init_dataset
@@ -116,9 +115,9 @@ def test_iterate_seqs_no_chunking_1():
     dataset.chunk_size = 0
     dataset.init_seq_order(1)
     seqs = list(dataset.iterate_seqs())
-    assert_equal(len(seqs), 2)
-    assert_equal(seqs[0], (0, 0, 11))  # seq-idx, start-frame, end-frame
-    assert_equal(seqs[1], (1, 0, 11))
+    assert len(seqs) == 2
+    assert seqs[0] == (0, 0, 11)  # seq-idx, start-frame, end-frame
+    assert seqs[1] == (1, 0, 11)
 
 
 def test_iterate_seqs_chunking_1():
@@ -129,13 +128,13 @@ def test_iterate_seqs_chunking_1():
     seqs = list(dataset.iterate_seqs())
     for s in seqs:
         print(s)
-    assert_equal(len(seqs), 6)
-    assert_equal(seqs[0], (0, 0, 10))  # seq-idx, start-frame, end-frame
-    assert_equal(seqs[1], (0, 5, 11))
-    assert_equal(seqs[2], (0, 10, 11))
-    assert_equal(seqs[3], (1, 0, 10))
-    assert_equal(seqs[4], (1, 5, 11))
-    assert_equal(seqs[5], (1, 10, 11))
+    assert len(seqs) == 6
+    assert seqs[0] == (0, 0, 10)  # seq-idx, start-frame, end-frame
+    assert seqs[1] == (0, 5, 11)
+    assert seqs[2] == (0, 10, 11)
+    assert seqs[3] == (1, 0, 10)
+    assert seqs[4] == (1, 5, 11)
+    assert seqs[5] == (1, 10, 11)
 
 
 def test_iterate_seqs_chunking_varying_sequence_length():
@@ -148,15 +147,15 @@ def test_iterate_seqs_chunking_varying_sequence_length():
     seqs = list(dataset.iterate_seqs())
     for s in seqs:
         print(s)
-    assert_equal(len(seqs), 8)
-    assert_equal(seqs[0], (0, NumbersDict({"data": 0, "classes": 0}), NumbersDict({"data": 12, "classes": 6})))
-    assert_equal(seqs[1], (0, NumbersDict({"data": 6, "classes": 3}), NumbersDict({"data": 18, "classes": 9})))
-    assert_equal(seqs[2], (0, NumbersDict({"data": 12, "classes": 6}), NumbersDict({"data": 24, "classes": 12})))
-    assert_equal(seqs[3], (0, NumbersDict({"data": 18, "classes": 9}), NumbersDict({"data": 24, "classes": 12})))
-    assert_equal(seqs[4], (1, NumbersDict({"data": 0, "classes": 0}), NumbersDict({"data": 12, "classes": 6})))
-    assert_equal(seqs[5], (1, NumbersDict({"data": 6, "classes": 3}), NumbersDict({"data": 18, "classes": 9})))
-    assert_equal(seqs[6], (1, NumbersDict({"data": 12, "classes": 6}), NumbersDict({"data": 24, "classes": 12})))
-    assert_equal(seqs[7], (1, NumbersDict({"data": 18, "classes": 9}), NumbersDict({"data": 24, "classes": 12})))
+    assert len(seqs) == 8
+    assert seqs[0] == (0, NumbersDict({"data": 0, "classes": 0}), NumbersDict({"data": 12, "classes": 6}))
+    assert seqs[1] == (0, NumbersDict({"data": 6, "classes": 3}), NumbersDict({"data": 18, "classes": 9}))
+    assert seqs[2] == (0, NumbersDict({"data": 12, "classes": 6}), NumbersDict({"data": 24, "classes": 12}))
+    assert seqs[3] == (0, NumbersDict({"data": 18, "classes": 9}), NumbersDict({"data": 24, "classes": 12}))
+    assert seqs[4] == (1, NumbersDict({"data": 0, "classes": 0}), NumbersDict({"data": 12, "classes": 6}))
+    assert seqs[5] == (1, NumbersDict({"data": 6, "classes": 3}), NumbersDict({"data": 18, "classes": 9}))
+    assert seqs[6] == (1, NumbersDict({"data": 12, "classes": 6}), NumbersDict({"data": 24, "classes": 12}))
+    assert seqs[7] == (1, NumbersDict({"data": 18, "classes": 9}), NumbersDict({"data": 24, "classes": 12}))
 
 
 def test_iterate_seqs_custom_chunking():
@@ -183,13 +182,13 @@ def test_iterate_seqs_custom_chunking():
     seqs = list(dataset.iterate_seqs())
     for s in seqs:
         print(s)
-    assert_equal(len(seqs), 6)
-    assert_equal(seqs[0], (0, 0, 10))  # seq-idx, start-frame, end-frame
-    assert_equal(seqs[1], (0, 5, 11))
-    assert_equal(seqs[2], (0, 10, 11))
-    assert_equal(seqs[3], (1, 0, 10))
-    assert_equal(seqs[4], (1, 5, 11))
-    assert_equal(seqs[5], (1, 10, 11))
+    assert len(seqs) == 6
+    assert seqs[0] == (0, 0, 10)  # seq-idx, start-frame, end-frame
+    assert seqs[1] == (0, 5, 11)
+    assert seqs[2] == (0, 10, 11)
+    assert seqs[3] == (1, 0, 10)
+    assert seqs[4] == (1, 5, 11)
+    assert seqs[5] == (1, 10, 11)
 
 
 def test_batches_recurrent_1():
@@ -202,7 +201,7 @@ def test_batches_recurrent_1():
     " :type: list[Batch] "
     while batch_gen.has_more():
         (batch,) = batch_gen.peek_next_n(1)
-        assert_is_instance(batch, Batch)
+        assert isinstance(batch, Batch)
         print("batch:", batch)
         print("batch seqs:", batch.seqs)
         all_batches.append(batch)
@@ -211,47 +210,47 @@ def test_batches_recurrent_1():
     # Each batch will have 1 batch-slice (max_seqs) and up to 10 frames (chunk_size).
     # For each seq, we get 3 chunks (chunk_step 5 for 11 frames).
     # Thus, 6 batches.
-    assert_equal(len(all_batches), 6)
-
-    assert_equal(all_batches[0].start_seq, 0)
-    assert_equal(all_batches[0].end_seq, 1)  # exclusive
-    assert_equal(len(all_batches[0].seqs), 1)  # 1 BatchSeqCopyPart
-    assert_equal(all_batches[0].seqs[0].seq_idx, 0)
-    assert_equal(all_batches[0].seqs[0].seq_start_frame, 0)
-    assert_equal(all_batches[0].seqs[0].seq_end_frame, 10)
-    assert_equal(all_batches[0].seqs[0].frame_length, 10)
-    assert_equal(all_batches[0].seqs[0].batch_slice, 0)
-    assert_equal(all_batches[0].seqs[0].batch_frame_offset, 0)
-
-    assert_equal(all_batches[1].start_seq, 0)
-    assert_equal(all_batches[1].end_seq, 1)  # exclusive
-    assert_equal(len(all_batches[1].seqs), 1)  # 1 BatchSeqCopyPart
-    assert_equal(all_batches[1].seqs[0].seq_idx, 0)
-    assert_equal(all_batches[1].seqs[0].seq_start_frame, 5)
-    assert_equal(all_batches[1].seqs[0].seq_end_frame, 11)
-    assert_equal(all_batches[1].seqs[0].frame_length, 6)
-    assert_equal(all_batches[1].seqs[0].batch_slice, 0)
-    assert_equal(all_batches[1].seqs[0].batch_frame_offset, 0)
-
-    assert_equal(all_batches[2].start_seq, 0)
-    assert_equal(all_batches[2].end_seq, 1)  # exclusive
-    assert_equal(len(all_batches[2].seqs), 1)  # 1 BatchSeqCopyPart
-    assert_equal(all_batches[2].seqs[0].seq_idx, 0)
-    assert_equal(all_batches[2].seqs[0].seq_start_frame, 10)
-    assert_equal(all_batches[2].seqs[0].seq_end_frame, 11)
-    assert_equal(all_batches[2].seqs[0].frame_length, 1)
-    assert_equal(all_batches[2].seqs[0].batch_slice, 0)
-    assert_equal(all_batches[2].seqs[0].batch_frame_offset, 0)
-
-    assert_equal(all_batches[3].start_seq, 1)
-    assert_equal(all_batches[3].end_seq, 2)  # exclusive
-    assert_equal(len(all_batches[3].seqs), 1)  # 1 BatchSeqCopyPart
-    assert_equal(all_batches[3].seqs[0].seq_idx, 1)
-    assert_equal(all_batches[3].seqs[0].seq_start_frame, 0)
-    assert_equal(all_batches[3].seqs[0].seq_end_frame, 10)
-    assert_equal(all_batches[3].seqs[0].frame_length, 10)
-    assert_equal(all_batches[3].seqs[0].batch_slice, 0)
-    assert_equal(all_batches[3].seqs[0].batch_frame_offset, 0)
+    assert len(all_batches) == 6
+
+    assert all_batches[0].start_seq == 0
+    assert all_batches[0].end_seq == 1  # exclusive
+    assert len(all_batches[0].seqs) == 1  # 1 BatchSeqCopyPart
+    assert all_batches[0].seqs[0].seq_idx == 0
+    assert all_batches[0].seqs[0].seq_start_frame == 0
+    assert all_batches[0].seqs[0].seq_end_frame == 10
+    assert all_batches[0].seqs[0].frame_length == 10
+    assert all_batches[0].seqs[0].batch_slice == 0
+    assert all_batches[0].seqs[0].batch_frame_offset == 0
+
+    assert all_batches[1].start_seq == 0
+    assert all_batches[1].end_seq == 1  # exclusive
+    assert len(all_batches[1].seqs) == 1  # 1 BatchSeqCopyPart
+    assert all_batches[1].seqs[0].seq_idx == 0
+    assert all_batches[1].seqs[0].seq_start_frame == 5
+    assert all_batches[1].seqs[0].seq_end_frame == 11
+    assert all_batches[1].seqs[0].frame_length == 6
+    assert all_batches[1].seqs[0].batch_slice == 0
+    assert all_batches[1].seqs[0].batch_frame_offset == 0
+
+    assert all_batches[2].start_seq == 0
+    assert all_batches[2].end_seq == 1  # exclusive
+    assert len(all_batches[2].seqs) == 1  # 1 BatchSeqCopyPart
+    assert all_batches[2].seqs[0].seq_idx == 0
+    assert all_batches[2].seqs[0].seq_start_frame == 10
+    assert all_batches[2].seqs[0].seq_end_frame == 11
+    assert all_batches[2].seqs[0].frame_length == 1
+    assert all_batches[2].seqs[0].batch_slice == 0
+    assert all_batches[2].seqs[0].batch_frame_offset == 0
+
+    assert all_batches[3].start_seq == 1
+    assert all_batches[3].end_seq == 2  # exclusive
+    assert len(all_batches[3].seqs) == 1  # 1 BatchSeqCopyPart
+    assert all_batches[3].seqs[0].seq_idx == 1
+    assert all_batches[3].seqs[0].seq_start_frame == 0
+    assert all_batches[3].seqs[0].seq_end_frame == 10
+    assert all_batches[3].seqs[0].frame_length == 10
+    assert all_batches[3].seqs[0].batch_slice == 0
+    assert all_batches[3].seqs[0].batch_frame_offset == 0
 
     # ...
 
@@ -263,7 +262,7 @@ def test_batches_non_recurrent_1():
     all_batches = []  # type: list[Batch]
     while batch_gen.has_more():
         (batch,) = batch_gen.peek_next_n(1)
-        assert_is_instance(batch, Batch)
+        assert isinstance(batch, Batch)
         print("batch:", batch)
         print("batch seqs:", batch.seqs)
         all_batches.append(batch)
@@ -271,63 +270,63 @@ def test_batches_non_recurrent_1():
 
     # Each batch will have 5 frames (batch_size), not more, i.e. a single seq.
     # There are 2 * 11 frames in total, so 5 batches, because we concat the 2 seqs, in the non-recurrent case.
-    assert_equal(len(all_batches), 5)
-
-    assert_equal(all_batches[0].start_seq, 0)
-    assert_equal(all_batches[0].end_seq, 1)  # exclusive
-    assert_equal(len(all_batches[0].seqs), 1)  # 1 BatchSeqCopyPart
-    assert_equal(all_batches[0].seqs[0].seq_idx, 0)
-    assert_equal(all_batches[0].seqs[0].seq_start_frame, 0)
-    assert_equal(all_batches[0].seqs[0].seq_end_frame, 5)
-    assert_equal(all_batches[0].seqs[0].frame_length, 5)
-    assert_equal(all_batches[0].seqs[0].batch_slice, 0)
-    assert_equal(all_batches[0].seqs[0].batch_frame_offset, 0)
-
-    assert_equal(all_batches[1].start_seq, 0)
-    assert_equal(all_batches[1].end_seq, 1)  # exclusive
-    assert_equal(len(all_batches[1].seqs), 1)  # 1 BatchSeqCopyPart
-    assert_equal(all_batches[1].seqs[0].seq_idx, 0)
-    assert_equal(all_batches[1].seqs[0].seq_start_frame, 5)
-    assert_equal(all_batches[1].seqs[0].seq_end_frame, 10)
-    assert_equal(all_batches[1].seqs[0].frame_length, 5)
-    assert_equal(all_batches[1].seqs[0].batch_slice, 0)
-    assert_equal(all_batches[1].seqs[0].batch_frame_offset, 0)
-
-    assert_equal(all_batches[2].start_seq, 0)
-    assert_equal(all_batches[2].end_seq, 2)  # exclusive. now both seq 0 and 1
-    assert_equal(len(all_batches[2].seqs), 2)  # two copies, BatchSeqCopyPart
-    assert_equal(all_batches[2].seqs[0].seq_idx, 0)
-    assert_equal(all_batches[2].seqs[0].seq_start_frame, 10)
-    assert_equal(all_batches[2].seqs[0].seq_end_frame, 11)
-    assert_equal(all_batches[2].seqs[0].frame_length, 1)
-    assert_equal(all_batches[2].seqs[0].batch_slice, 0)
-    assert_equal(all_batches[2].seqs[0].batch_frame_offset, 0)
-    assert_equal(all_batches[2].seqs[1].seq_idx, 1)
-    assert_equal(all_batches[2].seqs[1].seq_start_frame, 0)
-    assert_equal(all_batches[2].seqs[1].seq_end_frame, 4)
-    assert_equal(all_batches[2].seqs[1].frame_length, 4)
-    assert_equal(all_batches[2].seqs[1].batch_slice, 0)
-    assert_equal(all_batches[2].seqs[1].batch_frame_offset, 1)
-
-    assert_equal(all_batches[3].start_seq, 1)
-    assert_equal(all_batches[3].end_seq, 2)  # exclusive
-    assert_equal(len(all_batches[3].seqs), 1)  # 1 BatchSeqCopyPart
-    assert_equal(all_batches[3].seqs[0].seq_idx, 1)
-    assert_equal(all_batches[3].seqs[0].seq_start_frame, 4)
-    assert_equal(all_batches[3].seqs[0].seq_end_frame, 9)
-    assert_equal(all_batches[3].seqs[0].frame_length, 5)
-    assert_equal(all_batches[3].seqs[0].batch_slice, 0)
-    assert_equal(all_batches[3].seqs[0].batch_frame_offset, 0)
-
-    assert_equal(all_batches[4].start_seq, 1)
-    assert_equal(all_batches[4].end_seq, 2)  # exclusive
-    assert_equal(len(all_batches[4].seqs), 1)  # 1 BatchSeqCopyPart
-    assert_equal(all_batches[4].seqs[0].seq_idx, 1)
-    assert_equal(all_batches[4].seqs[0].seq_start_frame, 9)
-    assert_equal(all_batches[4].seqs[0].seq_end_frame, 11)
-    assert_equal(all_batches[4].seqs[0].frame_length, 2)
-    assert_equal(all_batches[4].seqs[0].batch_slice, 0)
-    assert_equal(all_batches[4].seqs[0].batch_frame_offset, 0)
+    assert len(all_batches) == 5
+
+    assert all_batches[0].start_seq == 0
+    assert all_batches[0].end_seq == 1  # exclusive
+    assert len(all_batches[0].seqs) == 1  # 1 BatchSeqCopyPart
+    assert all_batches[0].seqs[0].seq_idx == 0
+    assert all_batches[0].seqs[0].seq_start_frame == 0
+    assert all_batches[0].seqs[0].seq_end_frame == 5
+    assert all_batches[0].seqs[0].frame_length == 5
+    assert all_batches[0].seqs[0].batch_slice == 0
+    assert all_batches[0].seqs[0].batch_frame_offset == 0
+
+    assert all_batches[1].start_seq == 0
+    assert all_batches[1].end_seq == 1  # exclusive
+    assert len(all_batches[1].seqs) == 1  # 1 BatchSeqCopyPart
+    assert all_batches[1].seqs[0].seq_idx == 0
+    assert all_batches[1].seqs[0].seq_start_frame == 5
+    assert all_batches[1].seqs[0].seq_end_frame == 10
+    assert all_batches[1].seqs[0].frame_length == 5
+    assert all_batches[1].seqs[0].batch_slice == 0
+    assert all_batches[1].seqs[0].batch_frame_offset == 0
+
+    assert all_batches[2].start_seq == 0
+    assert all_batches[2].end_seq == 2  # exclusive. now both seq 0 and 1
+    assert len(all_batches[2].seqs) == 2  # two copies, BatchSeqCopyPart
+    assert all_batches[2].seqs[0].seq_idx == 0
+    assert all_batches[2].seqs[0].seq_start_frame == 10
+    assert all_batches[2].seqs[0].seq_end_frame == 11
+    assert all_batches[2].seqs[0].frame_length == 1
+    assert all_batches[2].seqs[0].batch_slice == 0
+    assert all_batches[2].seqs[0].batch_frame_offset == 0
+    assert all_batches[2].seqs[1].seq_idx == 1
+    assert all_batches[2].seqs[1].seq_start_frame == 0
+    assert all_batches[2].seqs[1].seq_end_frame == 4
+    assert all_batches[2].seqs[1].frame_length == 4
+    assert all_batches[2].seqs[1].batch_slice == 0
+    assert all_batches[2].seqs[1].batch_frame_offset == 1
+
+    assert all_batches[3].start_seq == 1
+    assert all_batches[3].end_seq == 2  # exclusive
+    assert len(all_batches[3].seqs) == 1  # 1 BatchSeqCopyPart
+    assert all_batches[3].seqs[0].seq_idx == 1
+    assert all_batches[3].seqs[0].seq_start_frame == 4
+    assert all_batches[3].seqs[0].seq_end_frame == 9
+    assert all_batches[3].seqs[0].frame_length == 5
+    assert all_batches[3].seqs[0].batch_slice == 0
+    assert all_batches[3].seqs[0].batch_frame_offset == 0
+
+    assert all_batches[4].start_seq == 1
+    assert all_batches[4].end_seq == 2  # exclusive
+    assert len(all_batches[4].seqs) == 1  # 1 BatchSeqCopyPart
+    assert all_batches[4].seqs[0].seq_idx == 1
+    assert all_batches[4].seqs[0].seq_start_frame == 9
+    assert all_batches[4].seqs[0].seq_end_frame == 11
+    assert all_batches[4].seqs[0].frame_length == 2
+    assert all_batches[4].seqs[0].batch_slice == 0
+    assert all_batches[4].seqs[0].batch_frame_offset == 0
 
 
 def test_batches_context_window():
@@ -344,7 +343,7 @@ def test_batches_context_window():
     all_batches = []  # type: list[Batch]
     while batch_gen.has_more():
         (batch,) = batch_gen.peek_next_n(1)
-        assert_is_instance(batch, Batch)
+        assert isinstance(batch, Batch)
         print("batch:", batch)
         print("batch seqs:", batch.seqs)
         all_batches.append(batch)
@@ -353,50 +352,50 @@ def test_batches_context_window():
     # Each batch will have 1 batch-slice (max_seqs) and up to 10 frames (chunk_size).
     # For each seq, we get 3 chunks (chunk_step 5 for 11 frames).
     # Thus, 3 batches.
-    assert_equal(len(all_batches), 3)
+    assert len(all_batches) == 3
     b0, b1, b2 = all_batches
     assert isinstance(b0, Batch)
     assert isinstance(b1, Batch)
     assert isinstance(b2, Batch)
 
-    assert_equal(b0.start_seq, 0)
-    assert_equal(b0.end_seq, 1)  # exclusive
-    assert_equal(len(b0.seqs), 1)  # 1 BatchSeqCopyPart
-    assert_equal(b0.seqs[0].seq_idx, 0)
-    assert_equal(b0.seqs[0].seq_start_frame["classes"], 0)
-    assert_equal(b0.seqs[0].seq_end_frame["classes"], 5)
-    assert_equal(b0.seqs[0].frame_length["classes"], 5)
-    assert_equal(b0.seqs[0].seq_start_frame["data"], 0 - ctx_left)
-    assert_equal(b0.seqs[0].seq_end_frame["data"], 5 + ctx_right)
-    assert_equal(b0.seqs[0].frame_length["data"], 5 + ctx_lr)
-    assert_equal(b0.seqs[0].batch_slice, 0)
-    assert_equal(b0.seqs[0].batch_frame_offset, 0)
-
-    assert_equal(b1.start_seq, 0)
-    assert_equal(b1.end_seq, 1)  # exclusive
-    assert_equal(len(b1.seqs), 1)  # 1 BatchSeqCopyPart
-    assert_equal(b1.seqs[0].seq_idx, 0)
-    assert_equal(b1.seqs[0].seq_start_frame["classes"], 5)
-    assert_equal(b1.seqs[0].seq_end_frame["classes"], 10)
-    assert_equal(b1.seqs[0].frame_length["classes"], 5)
-    assert_equal(b1.seqs[0].seq_start_frame["data"], 5 - ctx_left)
-    assert_equal(b1.seqs[0].seq_end_frame["data"], 10 + ctx_right)
-    assert_equal(b1.seqs[0].frame_length["data"], 5 + ctx_lr)
-    assert_equal(b1.seqs[0].batch_slice, 0)
-    assert_equal(b1.seqs[0].batch_frame_offset, 0)
-
-    assert_equal(b2.start_seq, 0)
-    assert_equal(b2.end_seq, 1)  # exclusive
-    assert_equal(len(b2.seqs), 1)  # 1 BatchSeqCopyPart
-    assert_equal(b2.seqs[0].seq_idx, 0)
-    assert_equal(b2.seqs[0].seq_start_frame["classes"], 10)
-    assert_equal(b2.seqs[0].seq_end_frame["classes"], 11)
-    assert_equal(b2.seqs[0].frame_length["classes"], 1)
-    assert_equal(b2.seqs[0].seq_start_frame["data"], 10 - ctx_left)
-    assert_equal(b2.seqs[0].seq_end_frame["data"], 11 + ctx_right)
-    assert_equal(b2.seqs[0].frame_length["data"], 1 + ctx_lr)
-    assert_equal(b2.seqs[0].batch_slice, 0)
-    assert_equal(b2.seqs[0].batch_frame_offset, 0)
+    assert b0.start_seq == 0
+    assert b0.end_seq == 1  # exclusive
+    assert len(b0.seqs) == 1  # 1 BatchSeqCopyPart
+    assert b0.seqs[0].seq_idx == 0
+    assert b0.seqs[0].seq_start_frame["classes"] == 0
+    assert b0.seqs[0].seq_end_frame["classes"] == 5
+    assert b0.seqs[0].frame_length["classes"] == 5
+    assert b0.seqs[0].seq_start_frame["data"] == 0 - ctx_left
+    assert b0.seqs[0].seq_end_frame["data"] == 5 + ctx_right
+    assert b0.seqs[0].frame_length["data"] == 5 + ctx_lr
+    assert b0.seqs[0].batch_slice == 0
+    assert b0.seqs[0].batch_frame_offset == 0
+
+    assert b1.start_seq == 0
+    assert b1.end_seq == 1  # exclusive
+    assert len(b1.seqs) == 1  # 1 BatchSeqCopyPart
+    assert b1.seqs[0].seq_idx == 0
+    assert b1.seqs[0].seq_start_frame["classes"] == 5
+    assert b1.seqs[0].seq_end_frame["classes"] == 10
+    assert b1.seqs[0].frame_length["classes"] == 5
+    assert b1.seqs[0].seq_start_frame["data"] == 5 - ctx_left
+    assert b1.seqs[0].seq_end_frame["data"] == 10 + ctx_right
+    assert b1.seqs[0].frame_length["data"] == 5 + ctx_lr
+    assert b1.seqs[0].batch_slice == 0
+    assert b1.seqs[0].batch_frame_offset == 0
+
+    assert b2.start_seq == 0
+    assert b2.end_seq == 1  # exclusive
+    assert len(b2.seqs) == 1  # 1 BatchSeqCopyPart
+    assert b2.seqs[0].seq_idx == 0
+    assert b2.seqs[0].seq_start_frame["classes"] == 10
+    assert b2.seqs[0].seq_end_frame["classes"] == 11
+    assert b2.seqs[0].frame_length["classes"] == 1
+    assert b2.seqs[0].seq_start_frame["data"] == 10 - ctx_left
+    assert b2.seqs[0].seq_end_frame["data"] == 11 + ctx_right
+    assert b2.seqs[0].frame_length["data"] == 1 + ctx_lr
+    assert b2.seqs[0].batch_slice == 0
+    assert b2.seqs[0].batch_frame_offset == 0
 
 
 def test_task12ax_window():
@@ -413,13 +412,13 @@ def test_task12ax_window():
     dataset2.init_seq_order(epoch=1)
     dataset1.load_seqs(0, 1)
     dataset2.load_seqs(0, 1)
-    assert_equal(dataset1.get_data_dim("data"), input_dim)
-    assert_equal(dataset2.get_data_dim("data"), input_dim * window)
+    assert dataset1.get_data_dim("data") == input_dim
+    assert dataset2.get_data_dim("data") == input_dim * window
     data1 = dataset1.get_data(0, "data")
     data2 = dataset2.get_data(0, "data")
     seq_len = data1.shape[0]
-    assert_equal(data1.shape, (seq_len, input_dim))
-    assert_equal(data2.shape, (seq_len, window * input_dim))
+    assert data1.shape == (seq_len, input_dim)
+    assert data2.shape == (seq_len, window * input_dim)
     data2a = data2.reshape(seq_len, window, input_dim)
     print("data1:")
     print(data1)
@@ -431,13 +430,13 @@ def test_task12ax_window():
     print(data2[0])
     print("data2a[0,0]:")
     print(data2a[0, 0])
-    assert_equal(list(data2a[0, 0]), [0] * input_dim)  # zero-padded left
-    assert_equal(list(data2a[0, 1]), list(data1[0]))
-    assert_equal(list(data2a[0, 2]), list(data1[1]))
-    assert_equal(list(data2a[1, 0]), list(data1[0]))
-    assert_equal(list(data2a[1, 1]), list(data1[1]))
-    assert_equal(list(data2a[1, 2]), list(data1[2]))
-    assert_equal(list(data2a[-1, 2]), [0] * input_dim)  # zero-padded right
+    assert list(data2a[0, 0]) == [0] * input_dim  # zero-padded left
+    assert list(data2a[0, 1]) == list(data1[0])
+    assert list(data2a[0, 2]) == list(data1[1])
+    assert list(data2a[1, 0]) == list(data1[0])
+    assert list(data2a[1, 1]) == list(data1[1])
+    assert list(data2a[1, 2]) == list(data1[2])
+    assert list(data2a[-1, 2]) == [0] * input_dim  # zero-padded right
 
 
 def test_get_seq_order():