tensorflow_datasets/testing pylint errors fixed

vijayphoenix · vijayphoenix · commit 6c5f55e566a1 · 2020-03-17T16:44:10.000+05:30
diff --git a/tensorflow_datasets/core/api_utils_test.py b/tensorflow_datasets/core/api_utils_test.py
@@ -34,11 +34,11 @@ def fn(a, b, c=api_utils.REQUIRED_ARG, d=4):
     self.assertEqual(["a", "b", "c", "d"], api_utils.getargspec(fn).args)
     self.assertEqual((1, 2, 3, 4), fn(a=1, b=2, c=3))
     predicate = "use keyword"
-    with self.assertRaisesWithPredicateMatch(ValueError, predicate):
+    with self.assert_raises_with_predicate_match(ValueError, predicate):
       fn(1, 2, 3)
-    with self.assertRaisesWithPredicateMatch(ValueError, predicate):
+    with self.assert_raises_with_predicate_match(ValueError, predicate):
       fn(1, b=2, c=3)
-    with self.assertRaisesWithPredicateMatch(ValueError, "is required"):
+    with self.assert_raises_with_predicate_match(ValueError, "is required"):
       fn(a=1, b=2)
 
   def test_disallow_positional_args_with_exceptions(self):
@@ -50,7 +50,7 @@ def fn(a, b, c=api_utils.REQUIRED_ARG, d=4):
     self.assertEqual(["a", "b", "c", "d"], api_utils.getargspec(fn).args)
     self.assertEqual((1, 2, 3, 4), fn(a=1, b=2, c=3))
     predicate = "use keyword"
-    with self.assertRaisesWithPredicateMatch(ValueError, predicate):
+    with self.assert_raises_with_predicate_match(ValueError, predicate):
       fn(1, 2, 3)
     self.assertEqual((1, 2, 3, 4), fn(1, b=2, c=3))
 
@@ -70,11 +70,11 @@ def fn(self, a, b, c=api_utils.REQUIRED_ARG, d=4):
 
     self.assertEqual((1, 2, 3, 4, 5), fn(a=1, b=2, c=3))
     predicate = "use keyword"
-    with self.assertRaisesWithPredicateMatch(ValueError, predicate):
+    with self.assert_raises_with_predicate_match(ValueError, predicate):
       fn(1, 2, 3)
-    with self.assertRaisesWithPredicateMatch(ValueError, predicate):
+    with self.assert_raises_with_predicate_match(ValueError, predicate):
       fn(1, b=2, c=3)
-    with self.assertRaisesWithPredicateMatch(ValueError, "is required"):
+    with self.assert_raises_with_predicate_match(ValueError, "is required"):
       fn(a=1, b=2)
 
 
diff --git a/tensorflow_datasets/core/dataset_builder_beam_test.py b/tensorflow_datasets/core/dataset_builder_beam_test.py
@@ -136,7 +136,7 @@ class BeamBasedBuilderTest(testing.TestCase):
   def test_download_prepare_raise(self):
     with testing.tmp_dir(self.get_temp_dir()) as tmp_dir:
       builder = DummyBeamDataset(data_dir=tmp_dir)
-      with self.assertRaisesWithPredicateMatch(ValueError, "no Beam Runner"):
+      with self.assert_raises_with_predicate_match(ValueError, "no Beam Runner"):
         builder.download_and_prepare()
 
   def _assertBeamGeneration(self, dl_config, dataset_cls, dataset_name):
diff --git a/tensorflow_datasets/core/dataset_builder_test.py b/tensorflow_datasets/core/dataset_builder_test.py
@@ -302,9 +302,9 @@ def test_latest_experimental_version(self):
 
   def test_with_unsupported_version(self):
     expected = "Dataset dummy_dataset_with_configs cannot be loaded at version"
-    with self.assertRaisesWithPredicateMatch(AssertionError, expected):
+    with self.assert_raises_with_predicate_match(AssertionError, expected):
       DummyDatasetWithConfigs(config="plus1", version="0.0.2")
-    with self.assertRaisesWithPredicateMatch(AssertionError, expected):
+    with self.assert_raises_with_predicate_match(AssertionError, expected):
       DummyDatasetWithConfigs(config="plus1", version="0.1.*")
 
   def test_previous_supported_version(self):
@@ -322,12 +322,12 @@ def test_non_preparable_version(self, *unused_mocks):
         "(available for `download_and_prepare`: 1.0.0, 2.0.0, 0.0.9, 0.0.8).")
     builder = DummyDatasetSharedGenerator(version="0.0.7")
     self.assertIsNotNone(builder)
-    with self.assertRaisesWithPredicateMatch(AssertionError, expected):
+    with self.assert_raises_with_predicate_match(AssertionError, expected):
       builder.download_and_prepare()
 
   def test_invalid_split_dataset(self):
     with testing.tmp_dir(self.get_temp_dir()) as tmp_dir:
-      with self.assertRaisesWithPredicateMatch(
+      with self.assert_raises_with_predicate_match(
           ValueError, "`all` is a special"):
         # Raise error during .download_and_prepare()
         registered.load(
diff --git a/tensorflow_datasets/core/dataset_info_test.py b/tensorflow_datasets/core/dataset_info_test.py
@@ -82,14 +82,14 @@ def tearDownClass(cls):
     testing.rm_tmp_dir(cls._tfds_tmp_dir)
 
   def test_undefined_dir(self):
-    with self.assertRaisesWithPredicateMatch(ValueError,
+    with self.assert_raises_with_predicate_match(ValueError,
                                              "undefined dataset_info_dir"):
       info = dataset_info.DatasetInfo(builder=self._builder)
       info.read_from_directory(None)
 
   def test_non_existent_dir(self):
     info = dataset_info.DatasetInfo(builder=self._builder)
-    with self.assertRaisesWithPredicateMatch(
+    with self.assert_raises_with_predicate_match(
         tf.errors.NotFoundError, "No such file or dir"):
       info.read_from_directory(_NON_EXISTENT_DIR)
 
diff --git a/tensorflow_datasets/core/download/extractor_test.py b/tensorflow_datasets/core/download/extractor_test.py
@@ -129,7 +129,7 @@ def test_wrong_method(self):
     from_path = os.path.join(self.test_data, 'archives', 'foo.csv.gz')
     promise = self.extractor.extract(from_path, ZIP, self.to_path)
     expected_msg = 'File is not a zip file'
-    with self.assertRaisesWithPredicateMatch(
+    with self.assert_raises_with_predicate_match(
         extractor.ExtractError, expected_msg):
       promise.get()
 
diff --git a/tensorflow_datasets/core/features/class_label_feature_test.py b/tensorflow_datasets/core/features/class_label_feature_test.py
@@ -86,9 +86,9 @@ def test_num_classes(self):
     self.assertEqual(1, labels.str2int('1'))
     self.assertEqual(u'1', labels.int2str(1))
 
-    with self.assertRaisesWithPredicateMatch(ValueError, 'Invalid'):
+    with self.assert_raises_with_predicate_match(ValueError, 'Invalid'):
       labels.str2int('10')
-    with self.assertRaisesWithPredicateMatch(ValueError, 'Invalid'):
+    with self.assert_raises_with_predicate_match(ValueError, 'Invalid'):
       labels.int2str(10)
 
   def test_str_classes(self):
@@ -119,7 +119,7 @@ def test_save_load(self):
     with testing.tmp_dir(self.get_temp_dir()) as tmp_dir:
       labels1.save_metadata(tmp_dir, 'test-labels')
       labels2.load_metadata(tmp_dir, 'test-labels')
-      with self.assertRaisesWithPredicateMatch(
+      with self.assert_raises_with_predicate_match(
           ValueError, 'number of names do not match the defined num_classes'):
         labels3.load_metadata(tmp_dir, 'test-labels')
 
@@ -134,27 +134,27 @@ def test_save_load(self):
   def test_names(self):
 
     labels = features.ClassLabel(names=['label3', 'label1', 'label2'])
-    with self.assertRaisesWithPredicateMatch(
+    with self.assert_raises_with_predicate_match(
         ValueError, 'overwrite already defined ClassLabel'):
       labels.names = ['other', 'labels']
 
     labels = features.ClassLabel()
     labels.names = ['label3', 'label1', 'label2']
-    with self.assertRaisesWithPredicateMatch(
+    with self.assert_raises_with_predicate_match(
         ValueError, 'overwrite already defined ClassLabel'):
       labels.names = ['other', 'labels']
 
     labels = features.ClassLabel(num_classes=3)
     labels.names = ['label3', 'label1', 'label2']
 
     labels = features.ClassLabel(num_classes=3)
-    with self.assertRaisesWithPredicateMatch(
+    with self.assert_raises_with_predicate_match(
         ValueError, 'number of names do not match the defined num_classes'):
       labels.names = ['label3', 'label1']
 
   def test_duplicate_names(self):
 
-    with self.assertRaisesWithPredicateMatch(
+    with self.assert_raises_with_predicate_match(
         ValueError, 'label names are duplicated'):
       features.ClassLabel(names=['label1', 'label1', 'label2'])
 
diff --git a/tensorflow_datasets/core/features/sequence_feature_test.py b/tensorflow_datasets/core/features/sequence_feature_test.py
@@ -224,7 +224,7 @@ def to_ragged(ex):
     self.assert_all_equal_nested(to_ragged(ex4), out)
 
     # Should raise error if two sequences do not have the same length.
-    with self.assertRaisesWithPredicateMatch(
+    with self.assert_raises_with_predicate_match(
         ValueError, 'length of all elements'):
       f.encode_example({
           'a': {'c': [[1, 1, 1], []]},
diff --git a/tensorflow_datasets/core/features/top_level_feature_test.py b/tensorflow_datasets/core/features/top_level_feature_test.py
@@ -37,7 +37,7 @@ def test_sequence_rank(self):
             shape=(None,), dtype=tf.int32, sequence_rank=1),
     }))
 
-    with self.assertRaisesWithPredicateMatch(
+    with self.assert_raises_with_predicate_match(
         NotImplementedError, 'mixing sequence and context'):
       top_level_feature._get_sequence_rank({
           'a': features_lib.TensorInfo(
@@ -100,14 +100,14 @@ def test_flatten_nested(self):
             'c': tf.int32,
         },
     })
-    with self.assertRaisesWithPredicateMatch(ValueError, 'received a non dict'):
+    with self.assert_raises_with_predicate_match(ValueError, 'received a non dict'):
       f._flatten({'b': 123})
 
-    with self.assertRaisesWithPredicateMatch(
+    with self.assert_raises_with_predicate_match(
         ValueError, 'Unrecognized keys: [\'d\']'):
       f._flatten({'b': {'c': 123, 'd': 123}})
 
-    with self.assertRaisesWithPredicateMatch(
+    with self.assert_raises_with_predicate_match(
         ValueError, 'Expected length 2 does not match input length 3'):
       f._nest([None, None, None])
 
@@ -129,7 +129,7 @@ def test_top_level(self):
         },
     })
 
-    with self.assertRaisesWithPredicateMatch(
+    with self.assert_raises_with_predicate_match(
         AssertionError, 'decoded when defined as top-level'):
       f['b'].decode_example({'c': 1})
 
diff --git a/tensorflow_datasets/core/file_format_adapter_test.py b/tensorflow_datasets/core/file_format_adapter_test.py
@@ -134,13 +134,13 @@ def test_dict_to_example(self):
     self.assertEqual([b"\x00\x00", b"\x00\x00"],
                      list(feature["e2"].bytes_list.value))
 
-    with self.assertRaisesWithPredicateMatch(ValueError, "Received an empty"):
+    with self.assert_raises_with_predicate_match(ValueError, "Received an empty"):
       # Raise error if an undefined empty value is given
       example_serializer._dict_to_tf_example({
           "empty": [],
       })
 
-    with self.assertRaisesWithPredicateMatch(ValueError, "not support type"):
+    with self.assert_raises_with_predicate_match(ValueError, "not support type"):
       # Raise error if an unsupported dtype is given
       example_serializer._dict_to_tf_example({
           "wrong_type": np.zeros(shape=(5,), dtype=np.complex64),
@@ -318,7 +318,7 @@ def assertWrongSpecs(self, specs, raise_cls, raise_msg):
 
     adapter = file_format_adapter.TFRecordExampleAdapter({"wrong_field": specs})
     # Raise error if an unsupported dtype is given
-    with self.assertRaisesWithPredicateMatch(raise_cls, raise_msg):
+    with self.assert_raises_with_predicate_match(raise_cls, raise_msg):
       adapter._parser._build_feature_specs()
 
   @testing.run_in_graph_and_eager_modes()
@@ -334,7 +334,7 @@ def assert_feature(self, specs, serialized_info, tests):
       with self._sub_test(str(i)):
 
         if test.raise_cls is not None:
-          with self.assertRaisesWithPredicateMatch(
+          with self.assert_raises_with_predicate_match(
               test.raise_cls, test.raise_msg):
             adapter._serializer.serialize_example(test.value)
           continue
diff --git a/tensorflow_datasets/core/lazy_imports_lib_test.py b/tensorflow_datasets/core/lazy_imports_lib_test.py
@@ -55,7 +55,7 @@ def test_import(self, module_name):
     getattr(tfds.core.lazy_imports, module_name)
 
   def test_bad_import(self):
-    with self.assertRaisesWithPredicateMatch(ImportError, "extras_require"):
+    with self.assert_raises_with_predicate_match(ImportError, "extras_require"):
       _ = tfds.core.lazy_imports.test_foo
 
 
diff --git a/tensorflow_datasets/core/registered_test.py b/tensorflow_datasets/core/registered_test.py
@@ -68,26 +68,26 @@ def test_registered(self):
     self.assertIn(name, registered.list_builders())
 
     nonexistent = "nonexistent_foobar_dataset"
-    with self.assertRaisesWithPredicateMatch(ValueError, "not found"):
+    with self.assert_raises_with_predicate_match(ValueError, "not found"):
       registered.builder(nonexistent)
     # Prints registered datasets
-    with self.assertRaisesWithPredicateMatch(ValueError, name):
+    with self.assert_raises_with_predicate_match(ValueError, name):
       registered.builder(nonexistent)
 
   def test_abstract(self):
     name = "unregistered_builder"
     self.assertEqual(name, UnregisteredBuilder.name)
     self.assertNotIn(name, registered.list_builders())
 
-    with self.assertRaisesWithPredicateMatch(ValueError, "an abstract class"):
+    with self.assert_raises_with_predicate_match(ValueError, "an abstract class"):
       registered.builder(name)
 
   def test_in_development(self):
     name = "in_development_dataset_builder"
     self.assertEqual(name, InDevelopmentDatasetBuilder.name)
     self.assertNotIn(name, registered.list_builders())
 
-    with self.assertRaisesWithPredicateMatch(
+    with self.assert_raises_with_predicate_match(
         ValueError,
         ("Dataset %s is under active development and is not available yet."
         ) % name):
@@ -200,7 +200,7 @@ def test_duplicate_dataset(self):
     class DuplicateBuilder(object):
       pass
 
-    with self.assertRaisesWithPredicateMatch(ValueError, "already registered"):
+    with self.assert_raises_with_predicate_match(ValueError, "already registered"):
       @six.add_metaclass(registered.RegisteredDataset)  # pylint: disable=function-redefined
       class DuplicateBuilder(object):
         pass
diff --git a/tensorflow_datasets/core/shuffle_test.py b/tensorflow_datasets/core/shuffle_test.py
@@ -114,9 +114,9 @@ def test_disk(self):
 
   def test_nonbytes(self):
     shuffler = shuffle.Shuffler(self.get_temp_dir(), 'split1')
-    with self.assertRaisesWithPredicateMatch(AssertionError, 'Only bytes'):
+    with self.assert_raises_with_predicate_match(AssertionError, 'Only bytes'):
       shuffler.add(1, u'a')
-    with self.assertRaisesWithPredicateMatch(AssertionError, 'Only bytes'):
+    with self.assert_raises_with_predicate_match(AssertionError, 'Only bytes'):
       shuffler.add(1, 123)
 
   def test_duplicate_key(self):
diff --git a/tensorflow_datasets/core/splits_test.py b/tensorflow_datasets/core/splits_test.py
@@ -268,12 +268,12 @@ def test_split_equality(self):
     test = tfds.Split.TEST
     train = tfds.Split.TRAIN
 
-    with self.assertRaisesWithPredicateMatch(
+    with self.assert_raises_with_predicate_match(
         NotImplementedError,
         "Equality is not implemented between merged/sub splits."):
       _ = test.subsplit(tfds.percent[10:]) == test.subsplit(tfds.percent[10:])
 
-    with self.assertRaisesWithPredicateMatch(
+    with self.assert_raises_with_predicate_match(
         NotImplementedError,
         "Equality is not implemented between merged/sub splits."):
       _ = test + train == test + train
@@ -485,23 +485,23 @@ def test_split_invalid(self):
     # Cannot add a split with himself
     test = tfds.Split.TEST
 
-    with self.assertRaisesWithPredicateMatch(ValueError, "added with itself"):
+    with self.assert_raises_with_predicate_match(ValueError, "added with itself"):
       split = test + test
       self._builder.values(split=split)
 
-    with self.assertRaisesWithPredicateMatch(ValueError, "added with itself"):
+    with self.assert_raises_with_predicate_match(ValueError, "added with itself"):
       split = (test.subsplit(tfds.percent[:10]) +
                test.subsplit(tfds.percent[10:]))
       self._builder.values(split=split)
 
     # Cannot slice a split twice
 
-    with self.assertRaisesWithPredicateMatch(
+    with self.assert_raises_with_predicate_match(
         ValueError, "has already been sliced"):
       split = test.subsplit(tfds.percent[:10]).subsplit(tfds.percent[:10])
       self._builder.values(split=split)
 
-    with self.assertRaisesWithPredicateMatch(
+    with self.assert_raises_with_predicate_match(
         ValueError, "has already been sliced"):
       split = test.subsplit(tfds.percent[10:]) + tfds.Split.TRAIN
       split = split.subsplit(tfds.percent[:50])
@@ -629,7 +629,7 @@ def test_split_file_instructions(self):
     }])
 
   def test_sub_split_wrong_key(self):
-    with self.assertRaisesWithPredicateMatch(
+    with self.assert_raises_with_predicate_match(
         ValueError, "Unknown split \"unknown\""):
       _ = self._builder.info.splits["unknown"]
 
diff --git a/tensorflow_datasets/core/tfrecords_reader_test.py b/tensorflow_datasets/core/tfrecords_reader_test.py
diff --git a/tensorflow_datasets/core/tfrecords_writer_test.py b/tensorflow_datasets/core/tfrecords_writer_test.py
diff --git a/tensorflow_datasets/core/utils/py_utils_test.py b/tensorflow_datasets/core/utils/py_utils_test.py
diff --git a/tensorflow_datasets/core/utils/version_test.py b/tensorflow_datasets/core/utils/version_test.py
diff --git a/tensorflow_datasets/testing/test_case.py b/tensorflow_datasets/testing/test_case.py
diff --git a/tensorflow_datasets/testing/test_utils.py b/tensorflow_datasets/testing/test_utils.py
