Changes to loading script, adapted from sjp

occlusion_swiss_judgment_prediction.py

@@ -14,11 +14,11 @@
 """Dataset for the Occlusion task."""
 
 import json
-import lzma
-import os
 
 import datasets
 
+logger = datasets.logging.get_logger(__name__)
+
 try:
     import lzma as xz
 except ImportError:
@@ -43,122 +43,121 @@ This dataset contains an implementation of occlusion for the SwissJudgmentPredic
 """
 _LICENSE = "cc-by-sa-4.0"
 
+_LANGUAGES = [
+    "de",
+    "fr",
+    "it",
+]
+
+_URL = "https://huggingface.co/datasets/rcds/occlusion_swiss_judgment_prediction/tree/main/data"
+
 _URLS = {
-    "full": "https://huggingface.co/datasets/rcds/occlusion_swiss_judgment_prediction"
+    "test_1": _URL + "test_occ_1.jsonl",
+    "test_2": _URL + "test_occ_2.jsonl",
+    "test_3": _URL + "test_occ_3.jsonl",
+    "test_4": _URL + "test_occ_4.jsonl",
 }
 
 
+class OcclusionSwissJudgmentPredictionConfig(datasets.BuilderConfig):
+    """BuilderConfig for OcclusionSwissJudgmentPrediction."""
+
+    def __init__(self, language: str, **kwargs):
+        """BuilderConfig for OcclusionSwissJudgmentPrediction.
+        Args:
+        language: One of de, fr, it, or all
+          **kwargs: keyword arguments forwarded to super.
+        """
+        super(OcclusionSwissJudgmentPredictionConfig, self).__init__(**kwargs)
+        self.language = language
+
+
 class OcclusionSwissJudgmentPrediction(datasets.GeneratorBasedBuilder):
-    """This dataset contains court decision for the occlusion task"""
+    """This dataset contains court decision for the occlusion task in swiss judgment prediction"""
 
     VERSION = datasets.Version("1.1.0")
-
+    BUILDER_CONFIG_CLASS = OcclusionSwissJudgmentPredictionConfig
     BUILDER_CONFIGS = [
-        datasets.BuilderConfig(name="full", description="This part covers the whole dataset"),
-    ]
-
-    DEFAULT_CONFIG_NAME = "full"  # It's not mandatory to have a default configuration. Just use one if it make sense.
+                          OcclusionSwissJudgmentPredictionConfig(
+                              name=lang,
+                              language=lang,
+                              version=datasets.Version("1.1.0", ""),
+                              description=f"Plain text import of OcclusionSwissJudgmentPrediction for the {lang} language",
+                          )
+                          for lang in _LANGUAGES
+                      ] + [
+                          OcclusionSwissJudgmentPredictionConfig(
+                              name="all",
+                              language="all",
+                              version=datasets.Version("1.1.0", ""),
+                              description="Plain text import of OcclusionSwissJudgmentPrediction for all languages",
+                          )
+                      ]
 
     def _info(self):
-        if self.config.name == "full":  # This is the name of the configuration selected in BUILDER_CONFIGS above
-            features = datasets.Features(
-                {
-                    "id": datasets.Value("int32"),
-                    "year": datasets.Value("int32"),
-                    "label": datasets.Value("string"),
-                    "language": datasets.Value("string"),
-                    "region": datasets.Value("string"),
-                    "canton": datasets.Value("string"),
-                    "legal_area": datasets.Value("string"),
-                    "explainability_label": datasets.Value("string"),
-                    "occluded_text": datasets.Value("string"),
-                    "text": datasets.Value("string")
-
-                }
-            )
+        features = datasets.Features(
+            {
+                "id": datasets.Value("int32"),
+                "year": datasets.Value("int32"),
+                "label": datasets.Value("string"),
+                "language": datasets.Value("string"),
+                "region": datasets.Value("string"),
+                "canton": datasets.Value("string"),
+                "legal_area": datasets.Value("string"),
+                "explainability_label": datasets.Value("string"),
+                "occluded_text": datasets.Value("string"),
+                "text": datasets.Value("string")
+
+            }
+        )
         return datasets.DatasetInfo(
-            # This is the description that will appear on the datasets page.
             description=_DESCRIPTION,
-            # This defines the different columns of the dataset and their types
-            features=features,  # Here we define them above because they are different between the two configurations
-            # If there's a common (input, target) tuple from the features, uncomment supervised_keys line below and
-            # specify them. They'll be used if as_supervised=True in builder.as_dataset.
-            # supervised_keys=("sentence", "label"),
-            # License for the dataset if available
+            features=features,
+            supervised_keys=None,
+            homepage="https://github.com/ninabaumgartner/SwissCourtRulingCorpus",
             license=_LICENSE,
-            # Citation for the dataset
             citation=_CITATION,
         )
 
     def _split_generators(self, dl_manager):
-        # If several configurations are possible (listed in BUILDER_CONFIGS), the configuration selected by the user is in self.config.name
-
-        # dl_manager is a datasets.download.DownloadManager that can be used to download and extract URLS
-        # It can accept any type or nested list/dict and will give back the same structure with the url replaced with path to local files.
-        # By default the archives will be extracted and a path to a cached folder where they are extracted is returned instead of the archive
-        urls = _URLS[self.config.name]
-        filepath_test_1 = dl_manager.download(os.path.join(urls, "data/test_occ_1.jsonl.xz"))
-        filepath_test_2 = dl_manager.download(os.path.join(urls, "data/test_occ_2.jsonl.xz"))
-        filepath_test_3 = dl_manager.download(os.path.join(urls, "data/test_occ_3.jsonl.xz"))
-        filepath_test_4 = dl_manager.download(os.path.join(urls, "data/test_occ_4.jsonl.xz"))
-
+        # dl_manager is a datasets.download.DownloadManager that can be used to
+        # download and extract URLs
+        try:
+            dl_dir = dl_manager.download(_URLS)
+        except Exception:
+            logger.warning(
+                "If this download failed try a few times before reporting an issue"
+            )
+            raise
         return [
             datasets.SplitGenerator(
                 name="test_1",
                 # These kwargs will be passed to _generate_examples
-                gen_kwargs={
-                    "filepath": filepath_test_1
-                },
+                gen_kwargs={"filepath": dl_dir["test_1"]},
             ),
             datasets.SplitGenerator(
                 name="test_2",
                 # These kwargs will be passed to _generate_examples
-                gen_kwargs={
-                    "filepath": filepath_test_2,
-                },
+                gen_kwargs={"filepath": dl_dir["test_2"]},
             ),
             datasets.SplitGenerator(
                 name="test_3",
                 # These kwargs will be passed to _generate_examples
-                gen_kwargs={
-                    "filepath": filepath_test_3
-                },
+                gen_kwargs={"filepath": dl_dir["test_3"]},
             ),
             datasets.SplitGenerator(
                 name="test_4",
                 # These kwargs will be passed to _generate_examples
-                gen_kwargs={
-                    "filepath": filepath_test_4,
-                },
-            )
+                gen_kwargs={"filepath": dl_dir["test_4"]},
+            ),
         ]
 
-        # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
-
-    def _generate_examples(self, filepath, split):
-        # The `key` is for legacy reasons (tfds) and is not important in itself, but must be unique for each example.
-        line_counter = 0
-        try:
-            with xz.open(open(filepath, "rb"), "rt", encoding="utf-8") as f:
-                for id, line in enumerate(f):
-                    line_counter += 1
-                    if line:
-                        data = json.loads(line)
-                        if self.config.name == "full":
-                            yield id, {
-                                "id": data["id"],
-                                "year": data["year"],
-                                "label": data["label"],
-                                "language": data["language"],
-                                "region": data["region"],
-                                "canton": data["canton"],
-                                "legal_area": data["legal_area"],
-                                "explainability_label": data["explainability_label"],
-                                "occluded_text": data["occluded_text"],
-                                "text": data["text"]
-
-                            }
-        except lzma.LZMAError as e:
-            print(split, e)
-            if line_counter == 0:
-                raise e
+    def _generate_examples(self, filepath):
+        """This function returns the examples in the raw (text) form."""
+        if self.config.language in ["all"] + _LANGUAGES:
+            with open(filepath, encoding="utf-8") as f:
+                for id_, row in enumerate(f):
+                    data = json.loads(row)
+                    _ = data.setdefault("source_language", "n/a")
+                    if self.config.language in ["all"] or data["language"] == self.config.language:
+                        yield id_, data