doc changes

AmericanStories.py

@@ -1,193 +1,177 @@
 import json
 import tarfile
-from datasets import DatasetInfo, DatasetBuilder, DownloadManager,BuilderConfig, SplitGenerator, Split, Version
+from datasets import DatasetInfo, DatasetBuilder, DownloadManager, BuilderConfig, SplitGenerator, Split, Version
 import datasets
 import os
 import requests
 import re
 from tqdm import tqdm
 
+SUPPORTED_YEARS = ["1774"]
+# Add years from 1798 to 1964 to the supported years
+SUPPORTED_YEARS = SUPPORTED_YEARS + [str(year) for year in range(1798, 1964)]
 
+def make_year_file_splits():
+    """
+    Collects a list of available files for each year.
 
-####data dir
-DATA_DIR="."
+    Returns:
+        dict: A dictionary mapping each year to its corresponding file URL.
+        list: A list of years.
+    """
+    base_url = "https://huggingface.co/datasets/dell-research-harvard/AmericanStories/resolve/main/"
 
-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_')]
-
-    ###Get only files for 17__ years
-    # data_files=[file for file in data_files if file.split('_')[1].startswith('17')]
-    ###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
-
-def make_year_file_splits(data_dir):
-    base_url="https://huggingface.co/datasets/dell-research-harvard/AmericanStories/resolve/main/"
-
-    # year_list=["1774","1804","1807"]
-    ###MAke a list of years from 1774 to 1960
-    print("Collecting all list of available files for each year")
-    year_list=[str(year) for year in range(1774,1960)]
-    data_files=[f"faro_{year}.tar.gz" for year in year_list]
-    url_list=[base_url+file for file in data_files]
-    ###Keep only valid urls
-    # url_list=[url for url in tqdm(url_list) if requests.get(url).status_code==200]
-    splits={year:file for year,file in zip(year_list,url_list)}
-    years=year_list
+    # Make a list of years from 1774 to 1960
+    year_list = [str(year) for year in range(1774, 1960)]
+    data_files = [f"faro_{year}.tar.gz" for year in year_list]
+    url_list = [base_url + file for file in data_files]
+    
+    splits = {year: file for year, file in zip(year_list, url_list)}
+    years = year_list
 
     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)
+_FILE_DICT, _YEARS = make_year_file_splits()
 
 
-###Make a class of builderconfig that supports an year_list attribute
-class MyBuilderConfig(datasets.BuilderConfig):
-    """BuilderConfig for MyDataset for different configurations."""
+class CustomBuilderConfig(datasets.BuilderConfig):
+    """BuilderConfig for AmericanStories dataset with different configurations."""
 
     def __init__(self, year_list=None, **kwargs):
-        """BuilderConfig for MyDataset.
+        """
+        BuilderConfig for AmericanStories dataset.
+
         Args:
-        **kwargs: keyword arguments forwarded to super.
+            year_list (list): A list of years to include in the dataset.
+            **kwargs: Additional keyword arguments forwarded to the superclass.
         """
-        super(MyBuilderConfig, self).__init__(**kwargs)
+        super(CustomBuilderConfig, self).__init__(**kwargs)
         self.year_list = year_list
 
-class AmericanStories(datasets.GeneratorBasedBuilder):
-    """TODO: Short description of my dataset."""
-
-    VERSION = datasets.Version("0.0.1")
 
+class AmericanStories(datasets.GeneratorBasedBuilder):
+    """Dataset builder class for AmericanStories dataset."""
 
+    VERSION = datasets.Version("0.1.0")
 
-    # 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')
-    ##Now use the custom builder config class
     BUILDER_CONFIGS = [
-        MyBuilderConfig(
+        CustomBuilderConfig(
             name="all_years",
             version=VERSION,
             description="All years in the dataset",
         ),
-        MyBuilderConfig(
+        CustomBuilderConfig(
             name="subset_years",
             version=VERSION,
             description="Subset of years in the dataset",
-            year_list=["1774","1804"],
-        )]
-    
-    DEFAULT_CONFIG_NAME = "subset_years"  # It's not mandatory to have a default configuration. Just use one if it make sense.
+            year_list=["1774", "1804"],
+        )
+    ]
+    DEFAULT_CONFIG_NAME = "subset_years"
 
     def _info(self):
-        # TODO: This method specifies the datasets.DatasetInfo object which contains informations and typings for the dataset
+        """
+        Specifies the DatasetInfo object for the AmericanStories dataset.
+
+        Returns:
+            datasets.DatasetInfo: The DatasetInfo object.
+        """
         features = datasets.Features(
-            {   "newspaper_name": datasets.Value("string"),
+            {
+                "article_id": datasets.Value("string"),
+                "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 ...
+                "article": 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"),
-            # Homepage of the dataset for documentation
-            # License for the dataset if available
-            # Citation for the dataset
+            features=features,
             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
+        """
+        Downloads and extracts the data, and defines the dataset splits.
+
+        Args:
+            dl_manager (datasets.DownloadManager): The DownloadManager instance.
+
+        Returns:
+            list: A list of SplitGenerator objects.
+        """
+        if self.config.name == "subset_years":
+            print(SUPPORTED_YEARS)
+            if not self.config.year_list:
+                raise ValueError("Please provide a valid year_list")
+            elif not set(self.config.year_list).issubset(set(SUPPORTED_YEARS)):
+                raise ValueError(f"Only {SUPPORTED_YEARS} are supported. Please provide a valid year_list")
 
-        # 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 = _FILE_DICT
-        year_list=_YEARS
+        year_list = _YEARS
 
-        ##Subset _FILE_DICT and year_list to only years in the config.year_list
+        # Subset _FILE_DICT and year_list to only include years in config.year_list
         if self.config.year_list:
-            urls={year:urls[year] for year in self.config.year_list}
-            year_list=self.config.year_list
+            urls = {year: urls[year] for year in self.config.year_list}
+            year_list = self.config.year_list
 
         data_dir = dl_manager.download_and_extract(urls)
 
-        ###REturn a list of splits - but each split is for a year!
+        # Return a list of splits, where each split corresponds to a year
         return [
             datasets.SplitGenerator(
-            name=year,
-            # These kwargs will be passed to _generate_examples
-            gen_kwargs={
-                "year_dir": os.path.join(data_dir[year], "mnt","122a7683-fa4b-45dd-9f13-b18cc4f4a187","ca_rule_based_fa_clean","faro_"+year),
-                "split": year,
-            },
-        ) for year in year_list
+                name=year,
+                gen_kwargs={
+                    "year_dir": os.path.join(data_dir[year], "mnt", "122a7683-fa4b-45dd-9f13-b18cc4f4a187", "ca_rule_based_fa_clean", "faro_" + year),
+                    "split": year,
+                },
+            ) for year in year_list
         ]
-    
 
+    def _generate_examples(self, year_dir, split):
+        """
+        Generates examples for the specified year and split.
 
+        Args:
+            year_dir (str): The directory path for the year.
+            split (str): The name of the split.
 
-    # 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.
+        Yields:
+            tuple: The key-value pair containing the example ID and the example data.
+        """
         for filepath in os.listdir(year_dir):
-            with open(os.path.join(year_dir,filepath), encoding="utf-8") as f:
-                    data = json.load(f)
-                    if "lccn" in data.keys():
-                        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"]
-                                }
+            with open(os.path.join(year_dir, filepath), encoding="utf-8") as f:
+                data = json.load(f)
+                if "lccn" in data.keys():
+                    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, {
+                            "article_id": article_id,
+                            "newspaper_name": newspaper_name,
+                            "edition": scan_edition,
+                            "date": scan_date,
+                            "page": scan_page,
+                            "headline": article["headline"],
+                            "byline": article["byline"],
+                            "article": article["article"],
+                        }