code: def fetch_mono_dataset(
      selection: Union[str, List[str], List[List[str]]],
      lang: str = "de",
      path: Optional[str] = _BASE_DATASET_PATH,
      overwrite: bool = False,
  ) -> List[str]:
      """Fetch the monolingual dataset provided by WMT
  
      Parameters
      ----------
      selection
          The selected datasets
      lang
          Language of the monolingual corpus
      path
  
      overwrite
          Whether to overwrite the downloaded dataset
  
      Returns
      -------
      src_corpus_paths
      """
      base_url_info = _MONOLINGUAL_URLS
      if isinstance(selection, str):
          selection = [selection]
      elif isinstance(selection, list):
          if isinstance(selection[0], list):
              corpus_paths = []
              for ele in selection:
                  ele_corpus_paths = fetch_mono_dataset(
                      ele, lang, path, overwrite
                  )
                  corpus_paths.extend(ele_corpus_paths)
              return corpus_paths
      else:
          raise NotImplementedError
      for sel in selection:
          base_url_info = base_url_info[sel]
  
      # Check the pair is valid
      available_lang = set(base_url_info.keys())
      if "url" in available_lang:
          available_lang.remove("url")
      if lang in available_lang:
          matched_lang = "{}".format(lang)
      else:
          raise ValueError(
              "Unsupported lang, lang={}. All supported: {}".format(
                  lang, available_lang
              )
          )
      save_dir_path = os.path.join(path, *(selection + [matched_lang]))
      if not os.path.exists(save_dir_path):
          os.makedirs(save_dir_path)
      out_path = os.path.join(save_dir_path, lang + ".txt")
      # Check for whether we can load the cached version
      if os.path.exists(out_path) and not overwrite:
          print(
              "Found data in {}, skip:\n"
              "\tSource: {}\n".format(selection + [lang], out_path)
          )
          return [out_path]
      lang_data_info = base_url_info[matched_lang]
      if "url" in lang_data_info:
          url_l = lang_data_info["url"]
      else:
          url_l = base_url_info["url"]
      # Download the data + Concatenate the file-parts (if necessary)
      download_fname_l = []
      if isinstance(url_l, str):
          url_l = [url_l]
      for url in url_l:
          original_filename = url[url.rfind("/") + 1 :]
          sha1_hash = _URL_FILE_STATS[url]
          if "url" in lang_data_info:
              save_path_l = (
                  [path] + selection + [matched_lang, original_filename]
              )
          else:
              save_path_l = [path] + selection + [original_filename]
          download_fname = _download_with_mirror(
              url, path=os.path.join(*save_path_l), sha1_hash=sha1_hash
          )
          download_fname_l.append(download_fname)
      if len(download_fname_l) > 1:
          data_path = concatenate_files(download_fname_l)
      else:
          data_path = download_fname_l[0]
  
      src_name = lang_data_info[lang]
      print(
          "Prepare data for {}\n"
          "\tCompressed File: {}\n"
          "\t{}: {}\n".format(
              selection + [lang], data_path, lang, out_path
          )
      )
      extract_mono_corpus(
          data_path, lang=lang, name=src_name, out_src_path=out_path
      )
      return [out_path]
  
imports: from typing import List, Union, IO, AnyStr, Tuple, Optional
  import re
  import os
  import argparse
  import zipfile
  import shutil
  import functools
  import tarfile
  import gzip
  import json
  from xml.etree import ElementTree
  from gluonnlp.data.filtering import ProfanityFilter
  from gluonnlp.utils.misc import file_line_number, download, load_checksum_stats
  from gluonnlp.base import get_data_home_dir, get_repo_url
label_desc: Use image node_id 10 for calling a global function with example usage: fetch_mono_dataset(selection, lang, path, overwrite) and returns: list, list, corpus_paths