modified the load script

minipileoflaw.py

@@ -1,158 +1,112 @@
-# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# TODO: Address all TODOs and remove all explanatory comments
-"""TODO: Add a description here."""
-
-
-import csv
+"""minipileoflaw"""
+
+
+import gzip
 import json
-import os
 
 import datasets
+try:
+    import lzma as xz
+except ImportError:
+    import pylzma as xz
 
 
-# TODO: Add BibTeX citation
-# Find for instance the citation on arxiv or on the dataset repo/website
-_CITATION = """\
-@InProceedings{huggingface:dataset,
-title = {A great new dataset},
-author={huggingface, Inc.
-},
-year={2020}
-}
+datasets.logging.set_verbosity_info()
+logger = datasets.logging.get_logger(__name__)
+
+
+_DESCRIPTION = """
+This is minipileoflaw
 """
 
-# TODO: Add description of the dataset here
-# You can copy an official description
-_DESCRIPTION = """\
-This new dataset is designed to solve this great NLP task and is crafted with a lot of care.
+_CITATION = """
+@misc{hendersonkrass2022pileoflaw,
+  url = {https://arxiv.org/abs/2207.00220},
+  author = {Henderson, Peter and Krass, Mark S. and Zheng, Lucia and Guha, Neel and Manning, Christopher D. and Jurafsky, Dan and Ho, Daniel E.},
+  title = {Pile of Law: Learning Responsible Data Filtering from the Law and a 256GB Open-Source Legal Dataset},
+  publisher = {arXiv},
+  year = {2022}
+}
 """
 
-# TODO: Add a link to an official homepage for the dataset here
-_HOMEPAGE = ""
+_URL = "https://huggingface.co/datasets/tomrb/minipileoflaw"
 
-# TODO: Add the licence for the dataset here if you can find it
-_LICENSE = ""
 
-# TODO: Add link to the official dataset URLs here
-# The HuggingFace Datasets library doesn't host the datasets but only points to the original files.
-# This can be an arbitrary nested dict/list of URLs (see below in `_split_generators` method)
-_URLS = {
-    "first_domain": "https://huggingface.co/datasets/tomrb/minipileoflaw/blob/main/data/minipileoflaw_acus_reports",
-    "second_domain": "https://huggingface.co/datasets/tomrb/minipileoflaw/blob/main/data/minipileoflaw_acus_reports",
-}
+BASE_URL = "https://huggingface.co/datasets/tomrb/minipileoflaw/blob/main/data/minipileoflaw_"
 
 
-# TODO: Name of the dataset usually matches the script name with CamelCase instead of snake_case
-class MiniPileOfLaw(datasets.GeneratorBasedBuilder):
-    """TODO: Short description of my dataset."""
+subsets_names = ['r_legaladvice', 'courtlistener_docket_entry_documents', 'atticus_contracts', 'courtlistener_opinions', 'federal_register', 'bva_opinions', 'us_bills', 'cc_casebooks', 'tos', 'euro_parl', 'nlrb_decisions', 'scotus_oral_arguments', 'cfr', 'state_codes', 'scotus_filings', 'exam_outlines', 'edgar', 'cfpb_creditcard_contracts', 'constitutions', 'congressional_hearings', 'oig', 'olc_memos', 'uscode', 'founding_docs', 'ftc_advisory_opinions', 'echr', 'eurlex', 'tax_rulings', 'un_debates', 'fre', 'frcp', 'canadian_decisions', 'eoir', 'dol_ecab', 'icj-pcij', 'uspto_office_actions', 'ed_policy_guidance', 'acus_reports', 'hhs_alj_opinions', 'sec_administrative_proceedings', 'fmshrc_bluebooks', 'resource_contracts', 'medicaid_policy_guidance', 'irs_legal_advice_memos', 'doj_guidance_documents']
 
-    VERSION = datasets.Version("1.1.0")
+_DATA_URL = {
+    key: {
+        "train": [f"{BASE_URL}{key}_train.csv"],
+        "validation": [f"{BASE_URL}{key}_valid.csv"]
+    }
+    for key in subsets_names
+}
 
-    # This is an example of a dataset with multiple configurations.
-    # If you don't want/need to define several sub-sets in your dataset,
-    # just remove the BUILDER_CONFIG_CLASS and the BUILDER_CONFIGS attributes.
+_VARIANTS = ["all"] + list(_DATA_URL.keys())
 
-    # If you need to make complex sub-parts in the datasets with configurable options
-    # You can create your own builder configuration class to store attribute, inheriting from datasets.BuilderConfig
-    # BUILDER_CONFIG_CLASS = MyBuilderConfig
 
-    # You will be able to load one or the other configurations in the following list with
-    # data = datasets.load_dataset('my_dataset', 'first_domain')
-    # data = datasets.load_dataset('my_dataset', 'second_domain')
-    BUILDER_CONFIGS = [
-        datasets.BuilderConfig(name="first_domain", version=VERSION, description="This part of my dataset covers a first domain"),
-        datasets.BuilderConfig(name="second_domain", version=VERSION, description="This part of my dataset covers a second domain"),
-    ]
+class MiniPileOfLaw(datasets.GeneratorBasedBuilder):
+    """TODO"""
 
-    DEFAULT_CONFIG_NAME = "first_domain"  # It's not mandatory to have a default configuration. Just use one if it make sense.
+    BUILDER_CONFIGS = [datasets.BuilderConfig(name) for name in _VARIANTS]
 
     def _info(self):
-        # TODO: This method specifies the datasets.DatasetInfo object which contains informations and typings for the dataset
-        
-        features = datasets.Features(
-            {
-                "text": datasets.Value("string"),
-                "created_timestamp": datasets.Value("string"),
-                "downloaded_timestamp": datasets.Value("string"),
-                "url": datasets.Value("string")
-
-                # These are the features of your dataset like images, labels ...
-            }
-        )
-        
         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"),
-            # Homepage of the dataset for documentation
-            homepage=_HOMEPAGE,
-            # License for the dataset if available
-            license=_LICENSE,
-            # Citation for the dataset
+            features=datasets.Features(
+                {
+                    "text": datasets.Value("string"),
+                    "created_timestamp": datasets.Value("string"),
+                    "downloaded_timestamp": datasets.Value("string"),
+                    "url": datasets.Value("string"),
+                }
+            ),
+            supervised_keys=None,
+            homepage=_URL,
             citation=_CITATION,
         )
 
     def _split_generators(self, dl_manager):
-        # TODO: This method is tasked with downloading/extracting the data and defining the splits depending on the configuration
-        # 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]
-        data_dir = dl_manager.download_and_extract(urls)
+        data_urls = {}
+        if self.config.name == "all":
+            data_sources = list(_DATA_URL.keys())
+        else:
+            data_sources = [self.config.name]
+        for split in ["train", "validation"]:
+            data_urls[split] = []
+            for source in data_sources:
+                for chunk in _DATA_URL[source][split]:
+                    data_urls[split].append(chunk)
+
+        train_downloaded_files = dl_manager.download(data_urls["train"])
+        validation_downloaded_files = dl_manager.download(data_urls["validation"])
         return [
+            datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"filepaths": train_downloaded_files}),
             datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                # These kwargs will be passed to _generate_examples
-                gen_kwargs={
-                    "filepath": os.path.join(data_dir, "train.csv"),
-                    "split": "train",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                # These kwargs will be passed to _generate_examples
-                gen_kwargs={
-                    "filepath": os.path.join(data_dir, "valid.csv"),
-                    "split": "valid",
-                },
+                name=datasets.Split.VALIDATION, gen_kwargs={"filepaths": validation_downloaded_files}
             ),
         ]
 
-    # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
-    def _generate_examples(self, filepath, split):
-        # TODO: This method handles input defined in _split_generators to yield (key, example) tuples from the dataset.
-        # The `key` is for legacy reasons (tfds) and is not important in itself, but must be unique for each example.
-        with open(filepath, encoding="utf-8") as f:
-            for key, row in enumerate(f):
-                data = json.loads(row)
-                if self.config.name == "first_domain":
-                    # Yields examples as (key, example) tuples
-                    yield key, {
-                        "sentence": data["sentence"],
-                        "option1": data["option1"],
-                        "answer": "" if split == "test" else data["answer"],
-                    }
-                else:
-                    yield key, {
-                        "sentence": data["sentence"],
-                        "option2": data["option2"],
-                        "second_domain_answer": "" if split == "test" else data["second_domain_answer"],
-                    }
+    def _generate_examples(self, filepaths):
+        """This function returns the examples in the raw (text) form by iterating on all the files."""
+        id_ = 0
+        for filepath in filepaths:
+            logger.info("Generating examples from = %s", filepath)
+            try:
+                with xz.open(open(filepath, "rb"), "rt", encoding="utf-8") as f:
+                    for line in f:
+                        if line:
+                            example = json.loads(line)
+                            if example is not None and isinstance(example, dict):
+                                yield id_, {
+                                    "text": example.get("text", ""),
+                                    "created_timestamp": example.get("created_timestamp", ""),
+                                    "downloaded_timestamp": example.get("downloaded_timestamp", ""),
+                                    "url": example.get("url", "")
+                                }
+                                id_ += 1
+            except:
+                print("Error reading file:", filepath)