testing_loader

AmericanStories.py

@@ -1,60 +1,167 @@
 import json
 import tarfile
-from datasets import DatasetInfo, DatasetBuilder, DownloadManager
+from datasets import DatasetInfo, DatasetBuilder, DownloadManager,BuilderConfig, SplitGenerator, Split, Version
+import datasets
+import os
+import requests
+import re
+
+
+###GEt list of files 
+DATASET_URL="https://huggingface.co/datasets/dell-research-harvard/AmericanStories/blob/main/"
+def get_list_of_files(url):
+    page = requests.get(url).text
+    links=re.findall(r'href=[\'"]?([^\'" >]+)', page)
+    ###Get only links containing faro_
+    links=[link for link in links if link.startswith('faro_')]
+    return links
+
+###Arrange into splits by year - files follow the format faro_YYYY.tar.gz
+def get_splits(links):
+    splits={}
+    years=[]
+    for link in links:
+        year=link.split('_')[1].split('.')[0]
+        if year not in splits:
+            splits[year]=[]
+        splits[year].append(link)
+        years.append(year)
+    return splits,years
+
+####data dir
+DATA_DIR="."
+
+def make_year_file_splits(data_dir):
+    ###Get list of files
+    data_files=os.listdir(data_dir)
+    ###Get only files containing faro_
+    data_files=[file for file in data_files if file.startswith('faro_')]
+
+    ###Arrange into splits by year - files follow the format faro_YYYY.tar.gz
+    splits={}
+    years=[]
+    for file in data_files:
+        year=file.split('_')[1].split('.')[0]
+        if year not in splits:
+            splits[year]=[]
+        splits[year].append(file)
+        years.append(year)
+    return splits, years
+
+
+
+
 
 _CITATION = """\
 Coming Soon
 """
 
 _DESCRIPTION = """\
-American Stories offers high-quality structured data from historical newspapers suitable for pre-training large language models to enhance the understanding of historical English and world knowledge. It can also be integrated into external databases of retrieval-augmented language models, enabling broader access to historical information, including interpretations of political events and intricate details about people's ancestors. Additionally, the structured article texts facilitate the application of transformer-based methods for popular tasks like detecting reproduced content, significantly improving accuracy compared to traditional OCR methods. American Stories serves as a substantial and valuable dataset for advancing multimodal layout analysis models and other multimodal applications.
-"""
+American Stories offers high-quality structured data from historical newspapers suitable for pre-training large language models to enhance the understanding of historical English and world knowledge. It can also be integrated into external databases of retrieval-augmented language models, enabling broader access to historical information, including interpretations of political events and intricate details about people's ancestors. Additionally, the structured article texts facilitate the application of transformer-based methods for popular tasks like detecting reproduced content, significantly improving accuracy compared to traditional OCR methods. American Stories serves as a substantial and valuable dataset for advancing multimodal layout analysis models and other multimodal applications. """
+
+_FILE_DICT,_YEARS=make_year_file_splits(DATA_DIR)
 
-class AmericanStories(DatasetBuilder):
-    VERSION = "0.0.1"
 
-    BUILDER_CONFIGS = [
-        DatasetBuilderConfig(
-            name="AmericanStories",
-            version=VERSION,
-            description=_DESCRIPTION,
-        ),
-    ]
 
-    def _info(self) -> DatasetInfo:
-        features = {
-            "feature_name": datasets.Value("string"),
-            # Define the other features of your dataset here
-        }
+
+class AmericanStories(datasets.GeneratorBasedBuilder):
+    """TODO: Short description of my dataset."""
+
+    VERSION = datasets.Version("0.0.1")
+
+    # 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.
+
+    # 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="american_stories", version="0.0.1", description="This part of my dataset covers a first domain")]
+
+
+    def _info(self):
+        # TODO: This method specifies the datasets.DatasetInfo object which contains informations and typings for the dataset
+        features = datasets.Features(
+            {   "newspaper_name": datasets.Value("string"),
+                "edition": datasets.Value("string"),
+                "date": datasets.Value("string"),
+                "page": datasets.Value("string"),
+                "headline": datasets.Value("string"),
+                "byline": datasets.Value("string"),
+                "article": 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,
-            features=datasets.Features(features),
+            # 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
+            # License for the dataset if available
+            # Citation for the dataset
             citation=_CITATION,
         )
 
-    def _split_generators(self, dl_manager):
-        data_files = [
-            os.path.join(self.data_dir, filename)
-            for filename in os.listdir(self.data_dir)
-            if filename.endswith(".tar.gz")
-        ]
-        
+    def _split_generators(self, dl_manager,online=False):
+        # 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
+        if not online:
+            urls = _FILE_DICT
+        else:
+            _URL_DICT,year_list=get_splits(get_list_of_files(DATASET_URL))
+            urls = _URL_DICT
+        year_list=_YEARS
+        data_dir = dl_manager.download_and_extract(urls)
+
+        ###REturn a list of splits - but each split is for a year!
         return [
-            self._generate_examples(data_file)
-            for data_file in data_files
+            datasets.SplitGenerator(
+            name=year,
+            # These kwargs will be passed to _generate_examples
+            gen_kwargs={
+                "year_dir": os.path.join(data_dir[year][0], "mnt/122a7683-fa4b-45dd-9f13-b18cc4f4a187/ca_rule_based_fa_clean/faro_"+year),
+                "split": year,
+            },
+        ) for year in year_list
         ]
+    
+
+
 
-    def _generate_examples(self, filepath: str) -> Iterator[datasets.Example]:
-        with tarfile.open(filepath, "r:gz") as tar:
-            for member in tar.getmembers():
-                if member.isfile() and member.name.endswith('.json'):
-                    file_name = os.path.basename(member.name)
-                    with tar.extractfile(member) as f:
-                        data = json.load(f)
-                        for idx, example in enumerate(data):
-                            # Process and yield each example
-                            yield idx, {
-                                "feature_name": example["feature_name"],
-                                # Assign values to other features of your dataset
+    # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
+    def _generate_examples(self, year_dir, 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.
+        for filepath in os.listdir(year_dir):
+            with open(os.path.join(year_dir,filepath), encoding="utf-8") as f:
+                    data = json.load(f)
+                    scan_id=filepath.split('.')[0]
+                    scan_date=filepath.split("_")[0]
+                    scan_page=filepath.split("_")[1]
+                    scan_edition=filepath.split("_")[-2][8:]
+                    newspaper_name=data["lccn"]["title"]
+                    full_articles_in_data=data["full articles"]
+                    for article in full_articles_in_data:
+                        article_id=str(article["full_article_id"]) +"_" +scan_id
+                        yield article_id,  {
+                            "newspaper_name": newspaper_name,
+                            "edition": scan_edition,
+                            "date": scan_date,
+                            "page": scan_page,
+                            "headline": article["headline"],
+                            "byline": article["byline"],
+                            "article": article["article"]
                             }