updates to datasheet

clean_and_deduplicate.py

@@ -4,13 +4,13 @@ from typing import cast
 
 from datasets import Dataset, load_dataset
 
+from dynaword.datasheet import DataSheet
 from dynaword.process_dataset import (
-    add_token_count,
     ensure_column_order,
-    remove_duplicate_text,
-    remove_empty_texts,
+    # add_token_count,
+    # remove_duplicate_text,
+    # remove_empty_texts,
 )
-from src.tests.readme_parsing import read_frontmatter_and_body
 
 logger = logging.getLogger(__name__)
 
@@ -22,21 +22,19 @@ logging.basicConfig(
 root = Path(__file__).parent
 
 data_path = root / "data"
-frontmatter, _ = read_frontmatter_and_body(root / "README.md")
+sheet = DataSheet.load_from_path(root / "README.md")
 
-for dataset_cfg in frontmatter["configs"][1:]:
+for dataset_cfg in sheet.frontmatter["configs"][1:]:
     logger.info(f"Processing {dataset_cfg['config_name']}")
     _data_path = data_path / dataset_cfg["config_name"]
-    readme = data_path / dataset_cfg["config_name"] / f"{dataset_cfg['config_name']}.md"
-    frontmatter, _ = read_frontmatter_and_body(readme)
     ds = load_dataset(_data_path.as_posix(), split="train")
 
     ds = cast(Dataset, ds)
 
-    ds = ds.remove_columns(["license", "metadata"])
-    ds = add_token_count(ds)
-    ds = remove_empty_texts(ds)
-    ds = remove_duplicate_text(ds)
+    ds = ds.remove_columns(["license", "metadata", "domain"])
+    # ds = add_token_count(ds)
+    # ds = remove_empty_texts(ds)
+    # ds = remove_duplicate_text(ds)
     ds = ensure_column_order(ds)
 
     # save dataset

data/botxt/botxt.md

@@ -1,21 +1,21 @@
 ---
 pretty_name: Bornholmsk
 language:
-  - da
+- da
 license: cc0-1.0
 license_name: CC-0
 size_categories:
-  - 1-10k
+- 1-10k
 task_categories:
-  - text-generation
-  - fill-mask
+- text-generation
+- fill-mask
 task_ids:
-  - language-modeling
+- language-modeling
 domains:
-  - Dialect
-  - Web
+- Dialect
+- Web
 source_datasets:
-  - danish-foundation-models/danish-gigaword
+- danish-foundation-models/danish-gigaword
 ---
 
 # Dataset Card for Bornholmsk 

data/dannet/dannet.md

@@ -1,20 +1,20 @@
 ---
 pretty_name: DanNet
 language:
-  - da
+- da
 license: other
 license_name: DanNet 1.0
 size_categories:
-  - 10k-100k
+- 10k-100k
 task_categories:
-  - text-generation
-  - fill-mask
+- text-generation
+- fill-mask
 task_ids:
-  - language-modeling
+- language-modeling
 source_datasets:
-  - danish-foundation-models/danish-gigaword
+- danish-foundation-models/danish-gigaword
 domains:
-  - Other
+- Other
 ---
 
 # Dataset Card for DanNet 
@@ -32,6 +32,7 @@ A WordNet is a lexico-semantic network which show the meaning and the relation b
 
 <!-- START-DESC-STATS -->
 - **Language**: dan, dansk, Danish
+- **Domains**: dan, dansk, Danish
 - **Number of samples**: 47.60K
 - **Number of tokens (Llama 3)**: 1.48M
 - **Average document length (characters)**: 90.88

src/dynaword/datasheet.py

@@ -1,32 +1,126 @@
+import json
+import logging
+from datetime import datetime
+from enum import Enum
 from pathlib import Path
-from typing import Any, Literal, Self
+from textwrap import dedent
+from typing import Any, Literal, Self, cast
 
 import yaml
+from datasets import Dataset, load_dataset
 from pydantic import BaseModel
 
-from dynaword.paths import repo_path
+from dynaword.descriptive_stats import DescriptiveStatsOverview
+from dynaword.plots import create_descriptive_statistics_plots
+
+logger = logging.getLogger(__name__)
+
 
 LICENSE_HEADER = "## License Information"
 
 
+class DEFAULT_SECTION_TAGS(Enum):
+    desc_stats = "DESC-STATS"
+    sample = "SAMPLE"
+    dataset_plots = "DATASET PLOTS"
+    short_description = "SHORT DESCRIPTION"
+
+
+DATASET_PLOTS_template = """
+<p align="center">
+<img src="./images/dist_document_length.png" width="600" style="margin-right: 10px;" />
+</p>
+"""
+
+
+SAMPLE_template = """
+```py
+{sample}
+```
+
+### Data Fields
+
+An entry in the dataset consists of the following fields:
+
+- `text`(`str`): The content of the document.
+- `source` (`str`): The source of the document (see [Source Data](#source-data)).
+- `id` (`str`): An unique identifier for each document.
+- `added` (`str`): An date for when the document was added to this collection.
+- `created` (`str`): An date range for when the document was originally created.
+- `license` (`str`): The license of the document. The licenses vary according to the source. 
+- `domain` (`str`): The domain of the source
+- `metadata/source-pretty` (`str`): The long form version of the short-form source name
+- `metadata/*`: Potentially additional metadata
+
+"""
+
+
+def human_readable_large_int(value: int) -> str:
+    thresholds = [
+        (1_000_000_000, "B"),
+        (1_000_000, "M"),
+        (1_000, "K"),
+    ]
+    for threshold, label in thresholds:
+        if value > threshold:
+            return f"{value/threshold:.2f}{label}"
+
+    return str(value)
+
+
+def create_sample_str(dataset: Dataset, max_str_len: int = 100):
+    sample = dataset[0]
+    for k in sample:
+        if isinstance(sample[k], str) and len(sample[k]) > max_str_len:
+            sample[k] = sample[k][:max_str_len] + "[...]"
+        if isinstance(sample[k], datetime):
+            sample[k] = str(sample[k])
+
+    json_sample = json.dumps(sample, indent=2, ensure_ascii=False)
+    sample_str = SAMPLE_template.format(sample=json_sample)
+
+    return sample_str
+
+
 class DataSheet(BaseModel):
     pretty_name: str
     license: Literal["cc0-1.0", "other", "cc-by-sa-4.0", "apache-2.0"]
+    license_name: str
     language: list[Literal["da"]]
+    domains: list[str]  # TODO: make literal
     path: Path
     frontmatter: dict[str, Any]
     body: str
 
+    @property
+    def short_description(self) -> str:
+        short_description = self.get_tag_content(
+            DEFAULT_SECTION_TAGS.short_description.value
+        )
+        if short_description.endswith("."):
+            short_description = short_description[:-1]
+        return short_description
+
     @property
     def license_information(self) -> str:
         return self.get_section_by_header(LICENSE_HEADER)
 
     @property
     def frontmatter_as_str(self) -> str:
-        return yaml.dump(self.frontmatter, indent=2)
+        return yaml.dump(self.frontmatter, indent=2, sort_keys=False)
 
     def to_str(self) -> str:
-        return f"---\n{self.frontmatter_as_str}---\n{self.body}"
+        return f"---\n{self.frontmatter_as_str.strip()}\n---\n\n{self.body.strip()}\n"
+
+    def get_dataset(self, **kwargs) -> Dataset:
+        ds_path = self.path.parent
+        ds = load_dataset(ds_path.as_posix(), split="train", **kwargs)
+        ds = cast(Dataset, ds)
+        return ds
+
+    def get_descritive_stats(self) -> DescriptiveStatsOverview:
+        path = self.path.parent / "descriptive_stats.json"
+        return DescriptiveStatsOverview.from_disk(path)
 
     def get_section_indices_by_header(self, header: str) -> tuple[int, int]:
         level = header.split(" ")[0].count("#")
@@ -80,7 +174,57 @@ class DataSheet(BaseModel):
         tag_start = f"<!-- START-{tag} -->"
         return self.body[s + len(tag_start) : e].strip()
 
+    def add_descriptive_stats(
+        self, descriptive_stats: DescriptiveStatsOverview | None = None
+    ) -> str:
+        if descriptive_stats is None:
+            d_stats = DescriptiveStatsOverview.from_dataset(self.get_dataset())
+        else:
+            d_stats = descriptive_stats
+
+        if len(self.language) != 1 and self.language[0] != "da":
+            raise NotImplementedError(
+                "This script only handles the language codes 'da'"
+            )
+        languages = "dan, dansk, Danish"
+
+        package = dedent(f"""
+        - **Language**: {languages}
+        - **Domains**: {self.domains}
+        - **Number of samples**: {human_readable_large_int(d_stats.number_of_samples)}
+        - **Number of tokens (Llama 3)**: {human_readable_large_int(d_stats.number_of_tokens)}
+        - **Average document length (characters)**: {d_stats.average_document_length:.2f}
+        """)
+
+        return self.replace_tag(
+            package=package,
+            tag=DEFAULT_SECTION_TAGS.desc_stats.value,
+        )
+
+    def add_dataset_plots(self, dataset: Dataset, create_plot: bool = True) -> str:
+        if create_plot:
+            create_descriptive_statistics_plots(
+                dataset=dataset, save_dir=self.path.parent
+            )
+        return self.replace_tag(
+            package=DATASET_PLOTS_template, tag=DEFAULT_SECTION_TAGS.dataset_plots.value
+        )
+
+    def add_sample_and_description(self, dataset: Dataset) -> str:
+        return self.replace_tag(
+            package=create_sample_str(dataset), tag=DEFAULT_SECTION_TAGS.sample.value
+        )
+
     def replace_tag(self, package: str, tag: str) -> str:
+        """Add replace a tag in the datasheet body.
+
+        Args:
+            package: What you want to replace it with
+            tag: What tag you want to replace
+
+        Returns:
+            The entire body text
+        """
         tag_start = f"<!-- START-{tag} -->"
         tag_end = f"<!-- END-{tag} -->"
 
@@ -100,9 +244,10 @@ class DataSheet(BaseModel):
             content = f.read()
         if content.startswith("---"):
             end_idx = content.find("---", 3)
+            start_idx_body = end_idx + 3
             if end_idx != -1:
                 frontmatter = content[3:end_idx].strip()
-                return yaml.safe_load(frontmatter), content[end_idx:]
+                return yaml.safe_load(frontmatter), content[start_idx_body:]
         raise ValueError(f"No frontmatter found in file: {file_path}")
 
     @classmethod
@@ -114,10 +259,12 @@ class DataSheet(BaseModel):
             license=frontmatter["license"],
             language=frontmatter["language"],
             pretty_name=frontmatter["pretty_name"],
+            domains=frontmatter["domains"],
+            license_name=frontmatter["license_name"],
             path=readme_path,
         )
 
-    def write_to_path(self, readme_path: Path | None) -> None:
+    def write_to_path(self, readme_path: Path | None = None) -> None:
         if readme_path is None:
             readme_path = self.path
         with readme_path.open("w") as f:
@@ -125,7 +272,10 @@ class DataSheet(BaseModel):
 
 
 if __name__ == "__main__":
-    sheet = DataSheet.load_from_path(repo_path / "data" / "botxt" / "botxt.md")
-    sheet.frontmatter
+    from dynaword.paths import repo_path
+
+    sheet = DataSheet.load_from_path(repo_path / "data" / "dannet" / "dannet.md")
+    ds = sheet.get_dataset()
 
-    print(yaml.dump(sheet.frontmatter, indent=2))
+    sheet.body = sheet.add_descriptive_stats(descriptive_stats=None)
+    sheet.write_to_path()

src/dynaword/descriptive_stats.py

@@ -0,0 +1,50 @@
+import json
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Self
+
+from datasets import Dataset
+
+from dynaword.git_utilities import (
+    get_current_revision,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def calculate_average_document_length(
+    dataset: Dataset, text_column: str = "text"
+) -> float:
+    texts = sum(len(t) for t in dataset[text_column])
+    return texts / len(dataset)
+
+
+@dataclass()
+class DescriptiveStatsOverview:
+    number_of_samples: int
+    average_document_length: float
+    number_of_tokens: int
+
+    @classmethod
+    def from_disk(cls, path: Path):
+        with path.open("r") as f:
+            data = json.load(f)
+        if "revision" in data:
+            data.pop("revision")
+        obj = cls(**data)
+        return obj
+
+    def to_disk(self, path: Path):
+        data = self.__dict__
+        data["revision"] = get_current_revision()
+        with path.with_suffix(".json").open("w") as f:
+            json.dump(self.__dict__, f, indent=2)
+
+    @classmethod
+    def from_dataset(cls, dataset: Dataset) -> Self:
+        return cls(
+            number_of_samples=len(dataset),
+            average_document_length=calculate_average_document_length(dataset),
+            number_of_tokens=sum(dataset["token_count"]),
+        )

src/dynaword/plots.py

@@ -0,0 +1,46 @@
+import logging
+
+import pandas as pd
+import plotnine as pn
+from datasets import Dataset
+
+from tests.readme_parsing import replace_tag
+
+logger = logging.getLogger(__name__)
+
+
+def create_descriptive_statistics_plots(
+    dataset: Dataset,
+    save_dir: Path,
+):
+    logger.info("creating descriptive statistics plot to readme.")
+    lengths = dataset["token_count"]
+    df = pd.DataFrame({"lengths": lengths, "Source": dataset["source"]})
+
+    plot = (
+        pn.ggplot(df, pn.aes(x="lengths", y=pn.after_stat("count")))
+        + pn.geom_histogram(bins=100)
+        + pn.labs(
+            x="Document Length (Tokens)",
+            y="Count",
+            title="Distribution of Document Lengths",
+        )
+        + pn.theme_minimal()
+        + pn.facet_wrap("Source", scales="free", ncol=3)
+    )
+
+    img_path = save_dir / "images"
+    img_path.mkdir(parents=False, exist_ok=True)
+    pn.ggsave(
+        plot,
+        img_path / "dist_document_length.png",
+        dpi=500,
+        width=10,
+        height=10,
+        units="in",
+        verbose=False,
+    )
+
+    replace_tag(
+        markdown=markdown_path, package=DATASET_PLOTS_template, tag="DATASET PLOTS"
+    )

src/dynaword/tables.py

@@ -0,0 +1,88 @@
+from pathlib import Path
+
+import pandas as pd
+
+from dynaword.datasheet import DataSheet, human_readable_large_int
+from dynaword.paths import repo_path
+
+main_sheet = DataSheet.load_from_path(repo_path / "README.md")
+frontmatter, _ = main_sheet.frontmatter
+_datasets = [
+    cfg["config_name"]  # type: ignore
+    for cfg in frontmatter["configs"]  # type: ignore
+    if cfg["config_name"] != "default"  # type: ignore
+]
+
+DEFAULT_LICENSE_REFERENCES = """[CC-0]: https://creativecommons.org/publicdomain/zero/1.0/legalcode.en
+[CC-BY-SA 4.0]: https://creativecommons.org/licenses/by-sa/4.0/deed.en
+[Apache 2.0]: https://www.apache.org/licenses/LICENSE-2.0
+"""
+
+
+def create_license_references() -> str:
+    license_references = DEFAULT_LICENSE_REFERENCES
+    for dataset in _datasets:
+        dataset_path = repo_path / "data" / dataset
+        readme_path = dataset_path / f"{dataset_path.name}.md"
+
+        sheet = DataSheet.load_from_path(readme_path)
+
+        if sheet.license == "other":
+            license_name = sheet.frontmatter["license_name"]
+            license_references += f"[{license_name}]: ./data/{dataset_path.name}/{dataset_path.name}.md#license-information\n"
+
+    return license_references
+
+
+def create_dataset_readme_references():
+    readme_references = ""
+
+    for dataset in _datasets:
+        dataset_path = repo_path / "data" / dataset
+
+        readme_references += (
+            f"[{dataset_path.name}]: data/{dataset_path.name}/{dataset_path.name}.md\n"
+        )
+    return readme_references
+
+
+def create_overview_table(repo_path: Path = repo_path) -> pd.DataFrame:
+    table = {
+        "Source": [],
+        "Description": [],
+        "Domain": [],
+        "N. Tokens": [],
+        "License": [],
+    }
+
+    for dataset in _datasets:
+        dataset_path = repo_path / "data" / dataset
+        readme_path = dataset_path / f"{dataset_path.name}.md"
+
+        sheet = DataSheet.load_from_path(readme_path)
+        desc_stats = sheet.get_descritive_stats()
+
+        table["Source"] += [f"[{dataset_path.name}]"]
+        table["License"] += [f"[{sheet.license_name}]"]
+        table["Description"] += [sheet.short_description]
+        table["N. Tokens"] += [desc_stats.number_of_tokens]
+
+    # total
+    table["Source"] += ["**Total**"]
+    table["Domain"] += [""]
+    table["License"] += [""]
+    table["Description"] += [""]
+    table["N. Tokens"] += [sum(table["N. Tokens"])]
+
+    df = pd.DataFrame.from_dict(table)
+    df = df.sort_values("N. Tokens")
+    df["N. Tokens"] = df["N. Tokens"].apply(human_readable_large_int)
+
+    return df
+
+def create_overview_table_str(repo_path: Path = repo_path) -> str:
+    main_table = create_overview_table(repo_path)
+    readme_references = create_dataset_readme_references()
+    license_references = create_license_references()
+    package = f"{main_table.to_markdown(index=False)}\n\n{readme_references}\n\n{license_references}\n\n"
+    return package

src/dynaword/update_descriptive_statistics.py

@@ -10,195 +10,29 @@ Example use:
 import argparse
 import json
 import logging
-from dataclasses import dataclass
-from datetime import datetime
 from pathlib import Path
-from textwrap import dedent
-from typing import Self, cast
+from typing import cast
 
-import pandas as pd
-import plotnine as pn
 from datasets import Dataset, load_dataset
 
 from dynaword.datasheet import DataSheet
+from dynaword.descriptive_stats import DescriptiveStatsOverview
 from dynaword.git_utilities import (
     check_is_ancestor,
-    get_current_revision,
     get_latest_revision,
 )
 from dynaword.paths import repo_path
-from tests.readme_parsing import get_tag_content, read_frontmatter_and_body, replace_tag
-
-frontmatter, _ = read_frontmatter_and_body(repo_path / "README.md")
-_datasets = [
-    cfg["config_name"]
-    for cfg in frontmatter["configs"]
-    if cfg["config_name"] != "default"
-]
+from dynaword.tables import create_overview_table_str
 
 logger = logging.getLogger(__name__)
 
-
-def human_readable_large_int(value: int) -> str:
-    thresholds = [
-        (1_000_000_000, "B"),
-        (1_000_000, "M"),
-        (1_000, "K"),
-    ]
-    for threshold, label in thresholds:
-        if value > threshold:
-            return f"{value/threshold:.2f}{label}"
-
-    return str(value)
-
-
-def calculate_average_document_length(
-    dataset: Dataset, text_column: str = "text"
-) -> float:
-    texts = sum(len(t) for t in dataset[text_column])
-    return texts / len(dataset)
-
-
-@dataclass()
-class DescriptiveStatsOverview:
-    number_of_samples: int
-    average_document_length: float
-    number_of_tokens: int
-    language: str = "dan, dansk, Danish"
-
-    @classmethod
-    def from_dataset(cls, dataset: Dataset) -> Self:
-        return cls(
-            number_of_samples=len(dataset),
-            average_document_length=calculate_average_document_length(dataset),
-            number_of_tokens=sum(dataset["token_count"]),
-        )
-
-    def to_markdown(self) -> str:
-        format = dedent(f"""
-
-        - **Language**: {self.language}
-        - **Domains**: {self.language}
-        - **Number of samples**: {human_readable_large_int(self.number_of_samples)}
-        - **Number of tokens (Llama 3)**: {human_readable_large_int(self.number_of_tokens)}
-        - **Average document length (characters)**: {self.average_document_length:.2f}
-
-        """)
-        return format
-
-    def add_to_markdown(self, markdown: str | Path) -> str:
-        return replace_tag(
-            markdown=markdown, package=self.to_markdown(), tag="DESC-STATS"
-        )
-
-    def to_disk(
-        self, path: Path
-    ):  # TODO: instead write this to the yaml header (and revision should not be added here)
-        data = self.__dict__
-        data["revision"] = get_current_revision()
-        with path.with_suffix(".json").open("w") as f:
-            json.dump(self.__dict__, f, indent=2)
-
-    @classmethod
-    def from_disk(cls, path: Path):
-        with path.open("r") as f:
-            data = json.load(f)
-        if "revision" in data:
-            data.pop("revision")
-        obj = cls(**data)
-        return obj
-
-
-sample_template = """
-```py
-{sample}
-```
-
-### Data Fields
-
-An entry in the dataset consists of the following fields:
-
-- `text`(`str`): The content of the document.
-- `source` (`str`): The source of the document (see [Source Data](#source-data)).
-- `id` (`str`): An unique identifier for each document.
-- `added` (`str`): An date for when the document was added to this collection.
-- `created` (`str`): An date range for when the document was originally created.
-- `license` (`str`): The license of the document. The licenses vary according to the source. 
-- `domain` (`str`): The domain of the source
-- `metadata/source-pretty` (`str`): The long form version of the short-form source name
-- `metadata/*`: Potentially additional metadata
-
-"""
-
-
-def add_sample(markdown_path: Path, dataset: Dataset, max_str_len: int = 100):
-    logger.info("Adding dataset sample to readme")
-    sample = dataset[0]
-    for k in sample:
-        if isinstance(sample[k], str) and len(sample[k]) > max_str_len:
-            sample[k] = sample[k][:max_str_len] + "[...]"
-        if isinstance(sample[k], datetime):
-            sample[k] = str(sample[k])
-
-    json_sample = json.dumps(sample, indent=2, ensure_ascii=False)
-    sample_str = sample_template.format(sample=json_sample)
-
-    replace_tag(markdown=markdown_path, package=sample_str, tag="SAMPLE")
-
-
-DATASET_PLOTS_template = """
-<p align="center">
-<img src="./images/dist_document_length.png" width="600" style="margin-right: 10px;" />
-</p>
-"""
-
-
-def add_descriptive_statistics_plots(
-    markdown_path: Path,
-    dataset: Dataset,
-):
-    logger.info("Adding descriptive statistics plot to readme.")
-    lengths = [len(s) for s in dataset["text"]]
-    df = pd.DataFrame({"lengths": lengths, "Source": dataset["source"]})
-
-    plot = (
-        pn.ggplot(df, pn.aes(x="lengths", y=pn.after_stat("count")))
-        + pn.geom_histogram(bins=100)
-        + pn.labs(
-            x="Document Length (Characters)",
-            y="Count",
-            title="Distribution of Document Lengths",
-        )
-        + pn.theme_minimal()
-        + pn.facet_wrap("Source", scales="free", ncol=3)
-    )
-
-    img_path = markdown_path.parent / "images"
-    img_path.mkdir(parents=False, exist_ok=True)
-    pn.ggsave(
-        plot,
-        img_path / "dist_document_length.png",
-        dpi=500,
-        width=10,
-        height=10,
-        units="in",
-        verbose=False,
-    )
-
-    replace_tag(
-        markdown=markdown_path, package=DATASET_PLOTS_template, tag="DATASET PLOTS"
-    )
-
-
-def add_desc_statitics(
-    markdown_path: Path,
-    dataset: Dataset,
-    desc_stats_path: Path,
-) -> None:
-    logger.info("Adding descriptive statistics to readme.")
-    desc_stats = DescriptiveStatsOverview.from_dataset(dataset)
-    desc_stats.to_disk(desc_stats_path)
-    desc_stats.add_to_markdown(markdown_path)
+main_sheet = DataSheet.load_from_path(repo_path / "README.md")
+frontmatter, _ = main_sheet.frontmatter
+_datasets = [
+    cfg["config_name"]  # type: ignore
+    for cfg in frontmatter["configs"]  # type: ignore
+    if cfg["config_name"] != "default"  # type: ignore
+]
 
 
 def update_dataset(
@@ -216,6 +50,7 @@ def update_dataset(
 
     rev = get_latest_revision(dataset_path)
     desc_stats_path = dataset_path / "descriptive_stats.json"
+    markdown_path = dataset_path / readme_name
 
     if desc_stats_path.exists() and force is False:
         with desc_stats_path.open("r") as f:
@@ -229,20 +64,22 @@ def update_dataset(
             )
             return
 
-    readme_name = f"{dataset_name}.md" if readme_name is None else readme_name
-    markdown_path = dataset_path / readme_name
-
-    logger.info(f"Updating dataset: {dataset_name}")
-
+    logger.info(f"Computing descriptive stats for: {dataset_name}")
     ds = load_dataset(str(repo_path), dataset_name, split="train")
     ds = cast(Dataset, ds)
+    desc_stats = DescriptiveStatsOverview.from_dataset(ds)
+    desc_stats.to_disk(desc_stats_path)
 
-    add_desc_statitics(markdown_path, ds, desc_stats_path)
-    add_sample(markdown_path, ds)
-    add_descriptive_statistics_plots(markdown_path, ds)
+    logger.info(f"Updating datasheet for: {dataset_name}")
+    sheet = DataSheet.load_from_path(markdown_path)
+    sheet.body = sheet.add_descriptive_stats(descriptive_stats=desc_stats)
+    sheet.body = sheet.add_sample_and_description(ds)
+    sheet.body = sheet.add_dataset_plots(ds, create_plot=True)
 
+    logger.info("Updating Overview table")
     if dataset_name == "default":
-        update_main_table()
+        package = create_overview_table_str()
+        sheet.body = sheet.replace_tag(package=package, tag="MAIN TABLE")
 
 
 def create_parser():
@@ -277,74 +114,6 @@ def create_parser():
     return parser
 
 
-def create_main_table(repo_path: Path = repo_path) -> tuple[pd.DataFrame, str, str]:
-    table = {
-        "Source": [],
-        "Description": [],
-        "Domain": [],
-        "N. Tokens": [],
-        "License": [],
-    }
-    readme_references = ""
-    license_references = (
-        "[CC-0]: https://creativecommons.org/publicdomain/zero/1.0/legalcode.en\n"
-        + "[CC-BY-SA 4.0]: https://creativecommons.org/licenses/by-sa/4.0/deed.en\n"
-        + "[Apache 2.0]: https://www.apache.org/licenses/LICENSE-2.0\n"
-    )
-
-    for dataset in _datasets:
-        dataset_path = repo_path / "data" / dataset
-        readme_path = dataset_path / f"{dataset_path.name}.md"
-
-        sheet = DataSheet.load_from_path(readme_path)
-        frontmatter = sheet.frontmatter
-        body = sheet.body
-        desc_stats = DescriptiveStatsOverview.from_disk(
-            dataset_path / "descriptive_stats.json"
-        )
-
-        short_description = get_tag_content(body, tag="SHORT DESCRIPTION").strip()
-        if short_description.endswith("."):
-            short_description = short_description[:-1]
-        license, license_name = frontmatter["license"], frontmatter["license_name"]
-
-        table["Source"] += [f"[{dataset_path.name}]"]
-        readme_references += (
-            f"[{dataset_path.name}]: data/{dataset_path.name}/{dataset_path.name}.md\n"
-        )
-
-        table["License"] += [f"[{license_name}]"]
-        if license == "other":
-            license_references += f"[{license_name}]: ./data/{dataset_path.name}/{dataset_path.name}.md#license-information\n"
-        table["Description"] += [short_description]
-        table["N. Tokens"] += [desc_stats.number_of_tokens]
-
-    # total
-    table["Source"] += ["**Total**"]
-    table["Domain"] += [""]
-    table["License"] += [""]
-    table["Description"] += [""]
-    table["N. Tokens"] += [sum(table["N. Tokens"])]
-
-    df = pd.DataFrame.from_dict(table)
-    df = df.sort_values("N. Tokens")
-    df["N. Tokens"] = df["N. Tokens"].apply(human_readable_large_int)
-
-    return df, readme_references, license_references
-
-
-def update_main_table(repo_path: Path = repo_path) -> None:
-    logger.info("Updating MAIN TABLE")
-    main_table, readme_references, license_references = create_main_table(repo_path)
-    readme_path = repo_path / "README.md"
-    with readme_path.open("r") as f:
-        markdown = f.read()
-    package = f"{main_table.to_markdown(index=False)}\n\n{readme_references}\n\n{license_references}\n\n"
-    markdown = replace_tag(markdown, package=package, tag="MAIN TABLE")
-    with readme_path.open("w") as f:
-        f.write(markdown)
-
-
 def main(
     dataset: str | None = None,
     logging_level: int = 20,

src/tests/conftest.py

@@ -1,33 +1,14 @@
 from pathlib import Path
-from typing import Any
 
-import pytest
-import yaml
-
-from tests.readme_parsing import read_frontmatter_and_body
+from dynaword.datasheet import DataSheet
 
 root_path = Path(__file__).parent.parent.parent
-
 main_readme = root_path / "README.md"
 
-frontmatter, _ = read_frontmatter_and_body(main_readme)
+main_sheet = DataSheet.load_from_path(main_readme)
+
 DATASET_NAMES = [
     cfg["config_name"]
-    for cfg in frontmatter["configs"]
+    for cfg in main_sheet.frontmatter["configs"]
     if cfg["config_name"] != "default"
 ]
-
-
-@pytest.fixture()
-def repo_path() -> Path:
-    return root_path
-
-
-def readme_yaml_header(repo_path: Path) -> dict[str, Any]:
-    readme_path = repo_path / "README.md"
-
-    with readme_path.open("r") as f:
-        readme = f.read()
-
-    frontmatter = readme.split("---")[1]
-    return yaml.safe_load(frontmatter)

src/tests/test_dataset_schema.py

@@ -1,9 +1,7 @@
 from pathlib import Path
-from typing import Literal
 
 import pytest
 from datasets import load_dataset
-from pydantic import BaseModel
 
 from dynaword.dataset_structure import SampleSchema
 from dynaword.datasheet import DataSheet
@@ -22,21 +20,14 @@ def test_sample_schema(repo_path: Path, dataset_name: str):
     SampleSchema(**sample)
 
 
-class FrontmatterSchema(BaseModel):
-    pretty_name: str
-    language: list[Literal["da"]]
-    license: Literal["cc0-1.0", "other", "cc-by-sa-4.0", "apache-2.0"]
-
-
 @pytest.mark.parametrize("dataset_name", DATASET_NAMES)
 def test_dataset_readme(repo_path: Path, dataset_name: str):
     """tests that the dataset frontmatter and markdown follows the correct format."""
 
     readme = repo_path / "data" / dataset_name / f"{dataset_name}.md"
 
-    ds_sheet = DataSheet.load_from_path(readme)
-    frontmatter = ds_sheet.frontmatter
-    frontmatter_validated = FrontmatterSchema(**frontmatter)
+    # ensure that it can be loaded as a datasheet
+    ds_sheet = DataSheet.load_from_path(readme)  # fill fail if format is not correct
 
     # ensure tags:
     body = ds_sheet.body
@@ -46,9 +37,7 @@ def test_dataset_readme(repo_path: Path, dataset_name: str):
 
     h2_headings = {line for line in body.splitlines() if line.startswith("## ")}
 
-    if (
-        frontmatter_validated.license == "other"
-    ):  # ensure description of underspecified licenses
+    if ds_sheet.license == "other":  # ensure description of underspecified licenses
         assert "## License Information" in h2_headings
 
     # required headings