Refactor wmt_utils to add language_pair to SubDataset

wmt_utils.py

@@ -53,7 +53,7 @@ CWMT_SUBSET_NAMES = ["casia2015", "casict2011", "casict2015", "datum2015", "datu
 class SubDataset:
     """Class to keep track of information on a sub-dataset of WMT."""
 
-    def __init__(self, name, target, sources, url, path, manual_dl_files=None):
+    def __init__(self, name, url, path="", target=None, sources=None, language_pairs=None, manual_dl_files=None):
         """Sub-dataset of WMT.
 
         Args:
@@ -83,33 +83,34 @@ class SubDataset:
         self._manual_dl_files = manual_dl_files if manual_dl_files else []
         self.name = name
         self.target = target
-        self.sources = set(sources)
+        self.sources = set(sources) if sources else sources
+        self.language_pairs = language_pairs if language_pairs else {(src, target) for src in self.sources}
 
-    def _inject_language(self, src, strings):
+    def _inject_language(self, src, tgt, strings):
         """Injects languages into (potentially) template strings."""
-        if src not in self.sources:
-            raise ValueError(f"Invalid source for '{self.name}': {src}")
+        if (src, tgt) not in self.language_pairs:
+            raise ValueError(f"Invalid source for '{self.name}': ({src}-{tgt})")
 
         def _format_string(s):
-            if "{0}" in s and "{1}" and "{src}" in s:
-                return s.format(*sorted([src, self.target]), src=src)
+            if "{0}" in s and "{1}" in s and "{src}" in s:
+                return s.format(*sorted([src, tgt]), src=src)
             elif "{0}" in s and "{1}" in s:
-                return s.format(*sorted([src, self.target]))
+                return s.format(*sorted([src, tgt]))
             elif "{src}" in s:
-                return s.format(src=src)
+                return s.format(src=src, tgt=tgt)
             else:
                 return s
 
         return [_format_string(s) for s in strings]
 
-    def get_url(self, src):
-        return self._inject_language(src, self._urls)
+    def get_url(self, src, tgt):
+        return self._inject_language(src=src, tgt=tgt, strings=self._urls)
 
-    def get_manual_dl_files(self, src):
-        return self._inject_language(src, self._manual_dl_files)
+    def get_manual_dl_files(self, src, tgt):
+        return self._inject_language(src=src, tgt=tgt, strings=self._manual_dl_files)
 
-    def get_path(self, src):
-        return self._inject_language(src, self._paths)
+    def get_path(self, src, tgt):
+        return self._inject_language(src=src, tgt=tgt, strings=self._paths)
 
 
 # Subsets used in the training sets for various years of WMT.
@@ -677,14 +678,14 @@ class Wmt(datasets.GeneratorBasedBuilder):
     @property
     def subsets(self):
         """Subsets that make up each split of the dataset for the language pair."""
-        source, target = self.config.language_pair
+        language_pair = self.config.language_pair
         filtered_subsets = {}
         subsets = self._subsets if self.config.subsets is None else self.config.subsets
         for split, ss_names in subsets.items():
             filtered_subsets[split] = []
             for ss_name in ss_names:
                 dataset = DATASET_MAP[ss_name]
-                if dataset.target != target or source not in dataset.sources:
+                if language_pair not in dataset.language_pairs:
                     logger.info("Skipping sub-dataset that does not include language pair: %s", ss_name)
                 else:
                     filtered_subsets[split].append(ss_name)
@@ -708,7 +709,7 @@ class Wmt(datasets.GeneratorBasedBuilder):
             yield ex[language]
 
     def _split_generators(self, dl_manager):
-        source, _ = self.config.language_pair
+        source, target = self.config.language_pair
         manual_paths_dict = {}
         urls_to_download = {}
         for ss_name in itertools.chain.from_iterable(self.subsets.values()):
@@ -716,30 +717,30 @@ class Wmt(datasets.GeneratorBasedBuilder):
                 # CzEng1.7 is CzEng1.6 with some blocks filtered out. We must download
                 # the filtering script so we can parse out which blocks need to be
                 # removed.
-                urls_to_download[_CZENG17_FILTER.name] = _CZENG17_FILTER.get_url(source)
+                urls_to_download[_CZENG17_FILTER.name] = _CZENG17_FILTER.get_url(source, target)
 
             # get dataset
             dataset = DATASET_MAP[ss_name]
-            if dataset.get_manual_dl_files(source):
+            if dataset.get_manual_dl_files(source, target):
                 # TODO(PVP): following two lines skip configs that are incomplete for now
                 # +++++++++++++++++++++
                 logger.info("Skipping {dataset.name} for now. Incomplete dataset for {self.config.name}")
                 continue
                 # +++++++++++++++++++++
 
-                manual_dl_files = dataset.get_manual_dl_files(source)
+                manual_dl_files = dataset.get_manual_dl_files(source, target)
                 manual_paths = [
                     os.path.join(os.path.abspath(os.path.expanduser(dl_manager.manual_dir)), fname)
                     for fname in manual_dl_files
                 ]
                 assert all(
                     os.path.exists(path) for path in manual_paths
-                ), f"For {dataset.name}, you must manually download the following file(s) from {dataset.get_url(source)} and place them in {dl_manager.manual_dir}: {', '.join(manual_dl_files)}"
+                ), f"For {dataset.name}, you must manually download the following file(s) from {dataset.get_url(source, target)} and place them in {dl_manager.manual_dir}: {', '.join(manual_dl_files)}"
 
                 # set manual path for correct subset
                 manual_paths_dict[ss_name] = manual_paths
             else:
-                urls_to_download[ss_name] = dataset.get_url(source)
+                urls_to_download[ss_name] = dataset.get_url(source, target)
 
         # Download and extract files from URLs.
         downloaded_files = dl_manager.download_and_extract(urls_to_download)
@@ -759,10 +760,10 @@ class Wmt(datasets.GeneratorBasedBuilder):
 
     def _generate_examples(self, split_subsets, extraction_map, with_translation=True):
         """Returns the examples in the raw (text) form."""
-        source, _ = self.config.language_pair
+        source, target = self.config.language_pair
 
         def _get_local_paths(dataset, extract_dirs):
-            rel_paths = dataset.get_path(source)
+            rel_paths = dataset.get_path(source, target)
             if len(extract_dirs) == 1:
                 extract_dirs = extract_dirs * len(rel_paths)
             return [
@@ -771,8 +772,8 @@ class Wmt(datasets.GeneratorBasedBuilder):
             ]
 
         def _get_filenames(dataset):
-            rel_paths = dataset.get_path(source)
-            urls = dataset.get_url(source)
+            rel_paths = dataset.get_path(source, target)
+            urls = dataset.get_url(source, target)
             if len(urls) == 1:
                 urls = urls * len(rel_paths)
             return [rel_path if rel_path else os.path.basename(url) for url, rel_path in zip(urls, rel_paths)]
@@ -782,7 +783,7 @@ class Wmt(datasets.GeneratorBasedBuilder):
             # +++++++++++++++++++++
             dataset = DATASET_MAP[ss_name]
             source, _ = self.config.language_pair
-            if dataset.get_manual_dl_files(source):
+            if dataset.get_manual_dl_files(source, target):
                 logger.info(f"Skipping {dataset.name} for now. Incomplete dataset for {self.config.name}")
                 continue
             # +++++++++++++++++++++