initial commit

.gitattributes

@@ -9,7 +9,6 @@
 *.joblib filter=lfs diff=lfs merge=lfs -text
 *.lfs.* filter=lfs diff=lfs merge=lfs -text
 *.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
 *.mlmodel filter=lfs diff=lfs merge=lfs -text
 *.model filter=lfs diff=lfs merge=lfs -text
 *.msgpack filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,25 @@
+# Python
+__pycache__/*
+*.pyc
+
+# cSpell
+cspell.json
+
+# debugfile
+.vscode/launch.json
+
+# tmp files
+tmp.py
+tmp.png
+
+# MacOS
+.DS_Store
+
+# tmp files
+tmp.py
+
+## to allow temporary data drops without pushing it to the hub
+data/*/tmp/*
+
+## node_modules
+**/node_modules/

.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "python.testing.pytestArgs": [
+        "src/tests"
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true,
+}

CHANGELOG.md

@@ -0,0 +1,18 @@
+
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/).
+
+## [v0.0.1] - 2025-01-25
+
+
+### Added
+
+- Added the `maalfrid` corpus
+
+
+## [v0.0.0] - 2025-01-24
+
+Project was initialized by copying the structure of the [Danish Dynaword](https://huggingface.co/datasets/danish-foundation-models/norwegian-dynaword).

CONTRIBUTING.md

@@ -0,0 +1,117 @@
+## Working with dataset locally
+
+A huggingface datasets repository is a GitHub repository like any other. You can simply download it like so:
+
+```bash
+git clone https://huggingface.co/datasets/danish-foundation-models/norwegian-dynaword
+cd norwegian-dynaword
+git lfs pull # download large files to ensure that tests works
+```
+
+You can the work with the dataset locally like so:
+
+```py
+from datasets import load_dataset
+
+name = "../."  # instead of "danish-foundation-models/norwegian-dynaword"
+dataset = load_dataset("../.", split="train")
+# make transformations here
+```
+
+> Note: While it is local Huggingface still uses a cache, therefore you might need to reset it after changes have been made to see that it works correctly. You can do this by deleting the cached files which you can locate using `dataset.cache_files`.
+
+## Adding a new dataset
+
+To add a new dataset you will have to create a folder under `data/{dataset_name}/`, which should look as follows:
+
+```
+  data/dataset_name
+  |- dataset_name.md
+  |- dataset_name.parquet
+  |- create.py               # optional
+```
+
+The create.py is an optional python script that allow you to recreate the dataset from the source. This is typically to allow us to reproduce the 
+dataset with fixes or update the dataset to the latest version using an API.
+
+## Installing dependencies
+
+This repo comes with a few dependencies you need to install to make this run. It uses a [makefile](https://opensource.com/article/18/8/what-how-makefile) to run commands and a [uv](https://docs.astral.sh/uv/) for package management. Once you have uv installed you can install the dependencies using:
+
+```bash
+make install
+```
+
+Now you can activate the environment with:
+
+```
+source .venv/bin/activate
+```
+
+## Running dataset tests
+
+This dataset is special as it comes with a test suite, e.g. testing in the ids are unique and that the format is consistent. You can run the suite using
+
+```bash
+make test
+```
+
+## Submitting a PR
+
+Creating a PR on Huggingface is a bit different from creating one on Github.
+
+1) Go to the community tab on huggingface press *new pull request* and choose *on your machine*. Specify the title of the your PR. Then you can simply:
+
+```bash
+git checkout -b {new branch name}
+# make your changes here 
+
+# push to hub
+# you might need to first login:
+# huggingface-cli login
+git push origin HEAD:refs/pr/{PR NUMBER}
+```
+Where HEAD refers to the current branch. 
+
+Before you make the PR do be sure to make sure that you have completed the checklist below.
+
+### Making changes to an existing PR
+
+As a contributor you might need to develop on an existing branch. To do so you you 
+```bash
+# fetch and checkout existing branch:
+git fetch origin refs/pr/{PR NUMBER}:pr/{PR NUMBER}
+git checkout pr/{PR NUMBER}
+# make your changes here
+
+# push changes
+```
+
+### Checklist
+
+- [ ] I have run the test suite using `make test` and all tests pass
+- [ ] I have added/changed a dataset:
+  - [ ] I have updated descriptive statistics using `make update-descriptive-statistics`
+  - [ ] I have bumped the version use `make bump-version`
+- [ ] If I have added a `create.py` script I have added the [script dependencies](https://docs.astral.sh/uv/guides/scripts/#declaring-script-dependencies) required to run that script.
+- [ ] I have updated the CHANGELOG.md if appropriate 
+
+
+### Examples of Previous PRs
+To see example PR you can see the following:
+
+- [Restructuring columns in the dataset](https://huggingface.co/datasets/danish-foundation-models/norwegian-dynaword/discussions/11)
+- [Adding a new dataset](https://huggingface.co/datasets/danish-foundation-models/norwegian-dynaword/discussions/15)
+- Updated [dataset description and metadata](https://huggingface.co/datasets/danish-foundation-models/norwegian-dynaword/discussions/20)
+
+## Frequently asked questions
+
+### Do you accept synthetic dataets
+
+Yes we do generally accept synthetic datasets since it will likely be a promising research direction for low- to mid-resource languages.
+However, you should be aware that synthetic dataset will probably require a more detailed examination and description.
+We will for instance examine the quality of the synthetic subset and whether the model used for the creation permits resharing of the synthetic data under permissible licenses.
+
+### Do you accept non-Norwegian data
+
+Generally this repository is intended for Norwegian text, however quite broadly defined. For instance, we do accept data containing [code-switching](https://www.google.com/search?client=safari&rls=en&q=code+switching&ie=UTF-8&oe=UTF-8) and historical Norwegian text.

README.md

@@ -0,0 +1,336 @@
+---
+annotations_creators:
+- no-annotation
+language_creators:
+- crowdsourced
+language:
+- da
+license: cc0-1.0
+multilinguality:
+- monolingual
+source_datasets:
+- original
+task_categories:
+- text-generation
+task_ids:
+- language-modeling
+tags:
+- text-corpus
+- continual-development
+- community-collaboration
+pretty_name: Norwegian Dynaword
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/*/*.parquet
+- config_name: maalfrid
+  data_files:
+  - split: train
+    path: data/maalfrid/*.parquet
+language_bcp47:
+- false
+- nno
+- nob
+- nor
+---
+
+<!-- 
+readme structure is inspired by:
+https://github.com/huggingface/datasets/blob/main/templates/README_guide.md 
+-->
+
+
+# 🧨 norwegian dynaword
+
+
+<!-- START README TABLE -->
+|              |                                                                                                                                                                |
+| ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Version** | 0.0.1 ([Changelog](/CHANGELOG.md)) |
+| **Language** | Norwegian (no, nor), including Bokmål (nob) and Nynorsk (nno)                                                                                                  |
+| **License**  | Openly Licensed, See the respective dataset                                                                                                                    |
+| **Models**   | Currently there is no models trained on this dataset                                                                                                           |
+| **Contact**  | If you have question about this project please create an issue [here](https://huggingface.co/datasets/danish-foundation-models/norwegian-dynaword/discussions) |
+
+
+
+<!-- END README TABLE -->
+
+## Table of Contents
+- [🧨 norwegian dynaword](#-norwegian-dynaword)
+  - [Table of Contents](#table-of-contents)
+  - [Dataset Description](#dataset-description)
+    - [Dataset Summary](#dataset-summary)
+    - [Loading the dataset](#loading-the-dataset)
+    - [Languages](#languages)
+    - [Domains](#domains)
+    - [Licensing](#licensing)
+  - [Dataset Structure](#dataset-structure)
+    - [Data Instances](#data-instances)
+    - [Data Fields](#data-fields)
+    - [Data Splits](#data-splits)
+  - [Dataset Creation](#dataset-creation)
+    - [Curation Rationale](#curation-rationale)
+    - [Annotations](#annotations)
+    - [Source Data](#source-data)
+    - [Data Collection and Processing](#data-collection-and-processing)
+    - [Dataset Statistics](#dataset-statistics)
+    - [Contributing to the dataset](#contributing-to-the-dataset)
+  - [Citation Information](#citation-information)
+  - [License information](#license-information)
+    - [Personal and Sensitive Information](#personal-and-sensitive-information)
+    - [Bias, Risks, and Limitations](#bias-risks-and-limitations)
+    - [Notice and takedown policy](#notice-and-takedown-policy)
+
+## Dataset Description
+
+<!-- START-DESC-STATS -->
+- **Number of samples**: 3.23M
+- **Number of tokens (Llama 3)**: 2.23B
+- **Average document length in tokens (min, max)**: 690.62 (4, 62.24K)
+<!-- END-DESC-STATS -->
+
+
+### Dataset Summary
+
+The Norwegian dynaword is a collection of Norwegian free-form text datasets from various domains. All of the datasets in the Norwegian Dynaword are openly licensed 
+and deemed permissible for training large language models. 
+
+Norwegian dynaword is continually developed, which means that the dataset will actively be updated as new datasets become available. If you would like to contribute a dataset see the [contribute section](#contributing-to-the-dataset).
+
+### Loading the dataset
+
+```py
+from datasets import load_dataset
+
+name = "danish-foundation-models/norwegian-dynaword"
+ds = load_dataset(name, split = "train")
+sample = ds[1] # see "Data Instances" below
+```
+
+or load it by streaming the data
+```py
+ds = load_dataset(name, split = "train", streaming=True)
+dataset_iter = iter(ds)
+sample = next(iter(dataset_iter))
+```
+
+You can also load a single subset at a time:
+```py
+ds = load_dataset(name, "adl", split = "train")
+```
+
+
+As Norwegian dynaword is continually expanding and curated you can make sure that you get the same dataset every time by specifying the revision:
+You can also load a single subset at a time:
+```py
+ds = load_dataset(name, revision="{desired revision}")
+```
+
+### Languages
+This dataset includes the following languages:
+
+- Norwegian (nor-Latn), including Bokmål (nob-Latn), and Nynorsk (nno-Latn) 
+
+In addition it likely contains small amounts of English due to code-switching and Danish due to the historical relation between the two languages and language misclassificaitons due to their similarity.
+
+Language is denoted using [BCP-47](https://en.wikipedia.org/wiki/IETF_language_tag), using the langauge code ISO [639-3](https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes) and the script code [ISO 15924](https://en.wikipedia.org/wiki/ISO_15924).
+
+### Domains
+
+This dynaword consist of data from various domains (e.g., legal, books, social media). The following table and figure give an overview of the relative distributions of these domains. To see a full overview of the source check out the [source data section](#source-data)
+
+<div style="display: flex; gap: 20px; align-items: flex-start;">
+
+<div style="flex: 1;">
+
+
+<!-- START-DOMAIN TABLE -->
+| Domain    | Sources    | N. Tokens   |
+|:----------|:-----------|:------------|
+| Web       | [maalfrid] | 2.23B       |
+| **Total** |            | 2.23B       |
+
+[maalfrid]: data/maalfrid/maalfrid.md
+<!-- END-DOMAIN TABLE -->
+
+</div>
+
+<div style="flex: 1;">
+
+<p align="center">
+<img src="./images/domain_distribution.png" width="400" style="margin-right: 10px;" />
+</p>
+
+</div>
+
+</div>
+
+
+### Licensing
+
+The following gives an overview of the licensing in the Dynaword. To get the exact license of the individual datasets check out the [overview table](#source-data).
+These license is applied to the constituent data, i.e., the text. The collection of datasets (metadata, quality control, etc.) is licensed under [CC-0](https://creativecommons.org/publicdomain/zero/1.0/legalcode.en).
+
+<!-- START-LICENSE TABLE -->
+| License                      | Sources    | N. Tokens   |
+|:-----------------------------|:-----------|:------------|
+| Other (Attribution required) | [maalfrid] | 2.23B       |
+| **Total**                    |            | 2.23B       |
+
+[maalfrid]: data/maalfrid/maalfrid.md
+<!-- END-LICENSE TABLE -->
+
+
+
+## Dataset Structure
+
+The dataset contains text from different sources which are thoroughly defined in [Source Data](#source-data).
+
+### Data Instances
+
+Each entry in the dataset consists of a single text with associated metadata
+
+<!-- START-SAMPLE -->
+```py
+{
+  "id": "maalfrid-0",
+  "text": "Elever med annet morsmål enn norsk og samisk har rett til særskilt norskopplæring til de har tilstre[...]",
+  "source": "maalfrid",
+  "added": "2026-01-25",
+  "created": "2021-01-01, 2021-12-31",
+  "token_count": 711
+}
+```
+
+### Data Fields
+
+An entry in the dataset consists of the following fields:
+
+- `id` (`str`): An unique identifier for each document.
+- `text`(`str`): The content of the document.
+- `source` (`str`): The source of the document (see [Source Data](#source-data)).
+- `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.
+- `token_count` (`int`): The number of tokens in the sample computed using the Llama 8B tokenizer
+<!-- END-SAMPLE -->
+
+### Data Splits
+
+The entire corpus is provided in the `train` split.
+
+## Dataset Creation
+
+### Curation Rationale
+
+These datasets were collected and curated with the intention of making openly license Norwegian data available. While this was collected with the intention of developing language models it is likely to have multiple other uses such as examining language development and differences across domains.
+
+
+### Annotations
+
+This data generally contains no annotation besides the metadata attached to each sample such as what domain it belongs to. 
+
+
+### Source Data
+
+Below follows a brief overview of the sources in the corpus along with their individual license. To get more information about the individual dataset click the hyperlink in the table.
+
+<details>
+<summary><b>Overview Table (click to unfold)</b></summary>
+
+You can learn more about each dataset by pressing the link in the first column.
+
+<!-- START-MAIN TABLE -->
+| Source     | Description                                            | Domain   | N. Tokens   | License    |
+|:-----------|:-------------------------------------------------------|:---------|:------------|:-----------|
+| [maalfrid] | Norwegian content from Norwegian institutions websites | Web      | 2.23B       | [NLOD 2.0] |
+| **Total**  |                                                        |          | 2.23B       |            |
+
+[maalfrid]: data/maalfrid/maalfrid.md
+
+
+[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
+[CC-BY 4.0]: https://creativecommons.org/licenses/by/4.0/deed.en
+[Apache 2.0]: https://www.apache.org/licenses/LICENSE-2.0
+[NLOD 2.0]: ./data/maalfrid/maalfrid.md#license-information
+<!-- END-MAIN TABLE -->
+
+</details>
+
+
+### Data Collection and Processing
+
+Norwegian dynaword is continually developed, which means that the dataset will actively be updated as new datasets become available. This means that the size of Dynaword increases over time as seen in the following plot:
+
+<p align="center">
+<img src="./images/tokens_over_time.svg" width="600" style="margin-right: 10px;" />
+</p>
+
+The data collection and processing varies depending on the dataset and is documentationed the individual datasheets, which is linked in the above table. If possible the collection is documented both in the datasheet and in the reproducible script (`data/{dataset}/create.py`).
+
+In addition to data specific processing we also run a series automated quality checks to ensure formatting (e.g. ensuring correctly formatted columns and unique IDs), quality checks (e.g. duplicate and empty string detection) and datasheet documentation checks. These checks are there to ensure a high quality of documentation and a minimal level of quality. To allow for the development of novel cleaning methodologies we do not provide more extensive cleaning.
+
+### Dataset Statistics
+The following plot(s) are intended to give an overview of docuements length in the various sources. 
+
+<p align="center">
+<img src="./images/dataset_size_plot.svg" width="600" style="margin-right: 10px;" />
+</p>
+
+
+
+### Contributing to the dataset
+
+We welcome contributions to the dataset, including new sources, improved data filtering, and other enhancements. To get started on contributing, please see [the contribution guidelines](CONTRIBUTING.md)
+
+## Citation Information
+
+If you use this work, please cite the [scientific article](https://arxiv.org/abs/2508.02271) introducing the Dynaword approach:
+
+> Enevoldsen, K.C., Jensen, K.N., Kostkan, J., Szab'o, B.I., Kardos, M., Vad, K., Heinsen, J., N'unez, A.B., Barmina, G., Nielsen, J., Larsen, R., Vahlstrup, P.B., Dalum, P.M., Elliott, D., Galke, L., Schneider-Kamp, P., & Nielbo, K.L. (2025). Dynaword: From One-shot to Continuously Developed Datasets.
+
+
+```
+@article{enevoldsen2025dynaword,
+  title={Dynaword: From One-shot to Continuously Developed Datasets},
+  author={Enevoldsen, Kenneth and Jensen, Kristian N{\o}rgaard and Kostkan, Jan and Szab{\'o}, Bal{\'a}zs and Kardos, M{\'a}rton and Vad, Kirten and N{\'u}{\~n}ez, Andrea Blasi and Barmina, Gianluca and Nielsen, Jacob and Larsen, Rasmus and others},
+  journal={arXiv preprint arXiv:2508.02271},
+  year={2025}
+}
+```
+
+Additionally, we recommend citing the relevant source datasets as well. See the individual datasheets for more information.
+
+## License information
+
+The license for each constituent dataset is supplied in the [Source data](#source-data) table. This license is applied to the constituent data, i.e., the text. The collection of datasets (metadata, quality control, etc.) is licensed under [CC-0](https://creativecommons.org/publicdomain/zero/1.0/legalcode.en).
+
+### Personal and Sensitive Information
+
+As far as we are aware the dataset does not contain information identifying sexual orientation, political beliefs, religion, or health connected along with a personal identifier of any non-public or non-historic figures.
+
+
+### Bias, Risks, and Limitations
+
+Certain works in this collection are historical works and thus reflect the linguistic, cultural, and ideological norms of their time.
+As such, it includes perspectives, assumptions, and biases characteristic of the period, which may be considered offensive or exclusionary by contemporary standards.
+
+
+### Notice and takedown policy
+We redistribute files shared with us under a license permitting such redistribution. If you have concerns about the licensing of these files, please [contact us](https://huggingface.co/datasets/danish-foundation-models/norwegian-dynaword/discussions/new). If you consider that the data contains material that infringe your copyright, please:
+- Clearly identify yourself with detailed contact information such as an address, a telephone number, or an email address at which you can be contacted.
+- Clearly reference the original work claimed to be infringed
+- Clearly identify the material claimed to be infringing and information reasonably sufficient to allow us to locate the material.
+You can contact us through this channel.
+We will comply with legitimate requests by removing the affected sources from the next release of the corpus
+
+---
+
+<h3 style="display: flex; align-items: center;">
+  <a href="https://www.foundationmodels.dk">
+    <img src="./docs/icon.png" width="30" style="margin-right: 10px;" />
+  </a>
+  A&nbsp;<a href=https://www.foundationmodels.dk>Danish Foundation Models</a>&nbsp;dataset
+</h3>

data/maalfrid/create.py

@@ -0,0 +1,134 @@
+# /// script
+# requires-python = ">=3.12"
+# dependencies = [
+#     "datasets>=3.2.0",
+# ]
+# ///
+
+"""
+Script for downloading and processing the dataset
+
+Note: To run this script, you need to set `GIT_LFS_SKIP_SMUDGE=1` to be able to install dynaword:
+```bash
+GIT_LFS_SKIP_SMUDGE=1 uv run data/maalfrid/create.py
+```
+
+TODO: Add to top once first PR is merged:
+
+# dependencies = [
+#     "datasets>=3.2.0",
+#     "dynaword"
+# ]
+# [tool.uv.sources]
+# dynaword = { git = "https://huggingface.co/datasets/danish-foundation-models/norwegian-dynaword", rev = "00e7f2aee7f7ad2da423419f77ecbb9c0536de0d" }
+"""
+
+import logging
+from datetime import date
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any
+
+from datasets import load_dataset
+
+from dynaword.process_dataset import (
+    add_token_count,
+    ensure_column_order,
+    remove_duplicate_text,
+    remove_empty_texts,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def filter_lang_id(
+    example: dict[str, Any], langs_to_keep: set[str] = {"no", "nn"}
+) -> bool:
+    return (
+        example["lang_fasttext"] in langs_to_keep
+        and float(example["lang_fasttext_conf"]) > 0.7
+    )
+
+
+def convert_to_row(
+    example: dict[str, Any],
+    source: str,
+) -> dict[str, Any]:
+    publish_year = example["publish_year"]
+    # convert to date string with end of year
+    date_end = f"{publish_year}-12-31"
+    date_start = f"{publish_year}-01-01"
+    row = {
+        "text": example["text"],
+        "created": f"{date_start}, {date_end}",
+    }
+    return row
+
+
+def main(hf_path: str, revision: str, source: str, num_proc: int):
+    save_path = Path(__file__).parent / f"{source}.parquet"
+
+    # load all splits
+    logger.info(f"Loading data from: {hf_path}")
+    ds = load_dataset(
+        hf_path,
+        streaming=False,
+        split="train+validation",
+        num_proc=num_proc,
+        revision=revision,
+    )
+
+    logger.info(f"Processing dataset - total number of rows: {len(ds)}")
+
+    ds = ds.remove_columns(["id"])
+    logger.info(f"Filter based on language id - total number of rows: {len(ds)}")
+    ds = ds.filter(filter_lang_id, num_proc=num_proc)
+
+    logger.info(f"Filter based on doctype '{source}' - total number of rows: {len(ds)}")
+    ds = ds.filter(lambda example: source in example["doc_type"], num_proc=num_proc)
+
+    logger.info("Converting to standard format")
+    ds = ds.map(
+        lambda example: convert_to_row(example, source),
+        remove_columns=ds.column_names,
+        num_proc=num_proc,
+    )
+    ds = ds.add_column("source", ["maalfrid"] * len(ds))
+    ds = ds.add_column("id", [f"maalfrid-{i}" for i in range(len(ds))])
+    ds = ds.add_column("added", [date.today().isoformat()] * len(ds))
+
+    ds = remove_empty_texts(ds)  # remove rows with empty text
+    ds = remove_duplicate_text(ds)  # remove rows with duplicate text
+    ds = add_token_count(ds)
+    ds = ensure_column_order(ds)
+
+    ds.to_parquet(save_path)
+
+
+if __name__ == "__main__":
+    config = SimpleNamespace(
+        hf_path="NbAiLab/NCC",
+        revision="857a5832b73ef33c66b5674d970777c39d991c0e",
+        num_proc=4,
+        source="maalfrid",
+    )
+
+    log_path = Path(__file__).parent / f"{config.source}.log"
+    # remove existing log file
+    if log_path.exists():
+        log_path.unlink()
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(levelname)s - %(message)s",
+        handlers=[
+            logging.StreamHandler(),
+            logging.FileHandler(log_path),
+        ],
+    )
+
+    main(
+        hf_path=config.hf_path,
+        revision=config.revision,
+        source=config.source,
+        num_proc=config.num_proc,
+    )

data/maalfrid/descriptive_stats.json

@@ -0,0 +1,9 @@
+{
+  "number_of_samples": 3229897,
+  "number_of_tokens": 2230639074,
+  "min_length_tokens": 4,
+  "max_length_tokens": 62236,
+  "number_of_characters": 6758480693,
+  "min_length_characters": 5,
+  "max_length_characters": 184633
+}

data/maalfrid/maalfrid.log

@@ -0,0 +1,10 @@
+2026-01-25 13:10:10,320 - INFO - Loading data from: NbAiLab/NCC
+2026-01-25 13:10:21,583 - INFO - Processing dataset - total number of rows: 8176399
+2026-01-25 13:10:21,671 - INFO - Filter based on language id - total number of rows: 8176399
+2026-01-25 13:10:21,912 - INFO - Filter based on doctype 'maalfrid' - total number of rows: 4133103
+2026-01-25 13:10:22,153 - INFO - Converting to standard format
+2026-01-25 13:10:34,441 - INFO - Removing empty texts
+2026-01-25 13:10:34,883 - INFO - Filtered 0 empty examples
+2026-01-25 13:10:34,883 - INFO - Removing duplicate texts
+2026-01-25 13:10:35,045 - INFO - Filtered 2077 duplicate examples
+2026-01-25 13:10:41,146 - INFO - Ensuring columns are in the correct order and are present

data/maalfrid/maalfrid.md

@@ -0,0 +1,136 @@
+---
+pretty_name: Maalfrid
+language:
+- da
+license: other
+license_name: NLOD 2.0
+task_categories:
+- text-generation
+- fill-mask
+task_ids:
+- language-modeling
+domains:
+- Web
+---
+
+# Dataset Card for Maalfrid
+
+<!-- START-SHORT DESCRIPTION -->
+Norwegian content from Norwegian institutions websites.
+<!-- END-SHORT DESCRIPTION -->
+
+Documents are derived from the [Målfrid collection](https://www.nb.no/sprakbanken/en/resource-catalogue/oai-nb-no-sbr-69/) as a subsection of the [Norwegian Colossal Corpus](https://huggingface.co/datasets/NbAiLab/NCC), which is a collection of multiple smaller Norwegian corpuses suitable for training large language models.
+
+## Dataset Description
+
+<!-- START-DESC-STATS -->
+- **Number of samples**: 3.23M
+- **Number of tokens (Llama 3)**: 2.23B
+- **Average document length in tokens (min, max)**: 690.62 (4, 62.24K)
+<!-- END-DESC-STATS -->
+
+
+## Dataset Structure
+An example from the dataset looks as follows.
+<!-- START-SAMPLE -->
+```py
+{
+  "id": "maalfrid-0",
+  "text": "Elever med annet morsmål enn norsk og samisk har rett til særskilt norskopplæring til de har tilstre[...]",
+  "source": "maalfrid",
+  "added": "2026-01-25",
+  "created": "2021-01-01, 2021-12-31",
+  "token_count": 711
+}
+```
+
+### Data Fields
+
+An entry in the dataset consists of the following fields:
+
+- `id` (`str`): An unique identifier for each document.
+- `text`(`str`): The content of the document.
+- `source` (`str`): The source of the document (see [Source Data](#source-data)).
+- `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.
+- `token_count` (`int`): The number of tokens in the sample computed using the Llama 8B tokenizer
+<!-- END-SAMPLE -->
+
+
+
+### Dataset Statistics
+
+<!-- START-DATASET PLOTS -->
+<p align="center">
+<img src="./images/dist_document_length.png" width="600" style="margin-right: 10px;" />
+</p>
+<!-- END-DATASET PLOTS -->
+
+## Additional Information
+
+## License Information
+
+This dataset is licensed under [NLOD 2.0](https://data.norge.no/nlod/en/2.0). 
+This license is derived from the original [publication](https://huggingface.co/datasets/NbAiLab/NCC), which is published by the 
+[National Library of Norway](https://www.nb.no/en/).
+
+## Filtering
+
+This subset is the result of the following filtering from all available data splits on the [NCC](https://huggingface.co/datasets/NbAiLab/NCC):
+
+- is_maalfrid: Documents, which are tagged as a part of the Målfrid corpus
+- language_filter: Document is classified as Norwegian with a threshold of 0.75
+- min_length: Document has at least 10 words (whitespace separated strings + punctuation)
+- alpha_ratio: The ratio of all words / words with only alphabetical characters is at least 0.7
+- min_stop_words: The document contains at least 2 Norwegian stop words
+- duplicate: Duplicate documents were removed
+
+| Filtering step  | Number of document |
+| --------------- | ------------------ |
+| is_maalfrid     | 4 719 569          |
+| language_filter | 51523              |
+| min_length      | 49 948             |
+| alpha_ratio     | 33 390             |
+| min_stop_words  | 33 340             |
+| duplicate       | 33 336             |
+
+
+### Citation Information
+
+If you use this source please cite the following articles:
+
+```
+@inproceedings{kummervold-etal-2022-norwegian-colossal,
+  title     = {The {N}orwegian colossal corpus: A text corpus for training large {N}orwegian language models},
+  author    = {Kummervold, Per E  and
+               Wetjen, Freddy    and
+               De la Rosa, Javier},
+  booktitle = {Proceedings of the Thirteenth Language Resources and Evaluation Conference (LREC)},
+  year      = {2022},
+  address   = {Marseille, France},
+  publisher = {European Language Resources Association},
+  url       = {https://aclanthology.org/2022.lrec-1.410},
+  pages     = {3852--3860},
+  abstract  = {Norwegian has been one of many languages lacking sufficient available text to train quality language models. In an attempt to bridge this gap, we introduce the Norwegian Colossal Corpus (NCC), which comprises 49GB of clean Norwegian textual data containing over 7B words. The NCC is composed of different and varied sources, ranging from books and newspapers to government documents and public reports, showcasing the various uses of the Norwegian language in society. The corpus contains mainly Norwegian Bokmål and Norwegian Nynorsk. Each document in the corpus is tagged with metadata that enables the creation of sub-corpora for specific needs. Its structure makes it easy to combine with large web archives that for licensing reasons could not be distributed together with the NCC. By releasing this corpus openly to the public, we hope to foster the creation of both better Norwegian language models and multilingual language models with support for Norwegian.},
+}
+
+@inproceedings{kummervold-etal-2021-operationalizing,
+  title     = {Operationalizing a National Digital Library: The Case for a {N}orwegian Transformer Model},
+  author    = {Kummervold, Per E  and
+               De la Rosa, Javier  and
+               Wetjen, Freddy  and
+               Brygfjeld, Svein Arne},
+  booktitle = {Proceedings of the 23rd Nordic Conference on Computational Linguistics (NoDaLiDa)},
+  year      = {2021},
+  address   = {Reykjavik, Iceland (Online)},
+  publisher = {Linköping University Electronic Press, Sweden},
+  url       = {https://aclanthology.org/2021.nodalida-main.3},
+  pages     = {20--29},
+  abstract  = {In this work, we show the process of building a large-scale training set from digital and digitized collections at a national library.
+  The resulting Bidirectional Encoder Representations from Transformers (BERT)-based language model for Norwegian outperforms multilingual BERT (mBERT) models
+  in several token and sequence classification tasks for both Norwegian Bokmål and Norwegian Nynorsk. Our model also improves the mBERT performance for other
+  languages present in the corpus such as English, Swedish, and Danish. For languages not included in the corpus, the weights degrade moderately while keeping strong multilingual properties. Therefore,
+  we show that building high-quality models within a memory institution using somewhat noisy optical character recognition (OCR) content is feasible, and we hope to pave the way for other memory institutions to follow.},
+}
+
+```

data/maalfrid/maalfrid.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:56447ced3202df58cd1ca99ab877265a77c96c60aba6f26a364b5a5ae624c5ec
+size 3934944751

descriptive_stats.json

@@ -0,0 +1,9 @@
+{
+  "number_of_samples": 3229897,
+  "number_of_tokens": 2230639074,
+  "min_length_tokens": 4,
+  "max_length_tokens": 62236,
+  "number_of_characters": 6758480693,
+  "min_length_characters": 5,
+  "max_length_characters": 184633
+}

makefile

@@ -0,0 +1,21 @@
+install:
+	@echo "--- 🚀 Installing project dependencies ---"
+	uv sync
+
+test:
+	@echo "--- 🧪 Running tests ---"
+	uv run pytest src/tests/ | tee test_results.log
+
+lint:
+	@echo "--- 🧹 Running linters ---"
+	ruff format . 			# running ruff formatting
+	ruff check . --fix  	# running ruff linting
+
+bump-version:
+	@echo "--- 🚀 Bumping patch version ---"
+	uv run src/dynaword/bump_version.py
+
+update-descriptive-statistics:
+	@echo "--- 🚀 Recomputing Descriptive statistics ---"
+	uv run src/dynaword/update_descriptive_statistics.py # compute missing descriptive statistics for all datasets
+	uv run src/dynaword/update_descriptive_statistics.py --dataset default --force # always ensure default dataset is up to date

pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "dynaword"
+version = "0.0.1"
+description = "project code for the norwegian dynaword project"
+readme = "README.md"
+requires-python = ">=3.12,<3.13" # 3.13 have issues with spacy and pytorch
+dependencies = [
+    # for commands
+    "datasets>=3.0.0", # loading and validating datasets
+    "pydantic>=2.10.4", # validating schemas
+    "tabulate>=0.9.0", # creating md table
+    "tomlkit>=0.13.2", # reading toml
+    "transformers>=4.47.1", # tokenization
+    # figures
+    "plotnine>=0.14.5",
+    "plotly>=6.0.1",
+    "nbformat>=4.2.0",
+    "kaleido==0.2.1",
+]
+
+[dependency-groups]
+dev = [
+    # development
+    "ipykernel>=6.29.5",
+    "pip>=25.0.1",
+    # test
+    "pytest>=8.3.4",
+    # formatting
+    "ruff>=0.8.3",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

src/dynaword/bump_version.py

@@ -0,0 +1,56 @@
+from pathlib import Path
+
+import tomlkit
+from packaging.version import Version
+
+from dynaword.paths import pyproject_path, readme_path
+
+
+def get_version(pyproject_path: Path = pyproject_path) -> str:
+    with pyproject_path.open("r") as f:
+        data = tomlkit.load(f)
+        return data["project"]["version"]  # type: ignore
+
+
+def update_pyproject_version(version: str, pyproject_path: Path) -> None:
+    with pyproject_path.open("r") as f:
+        data = tomlkit.load(f)
+        data["project"]["version"] = version  # type: ignore
+
+    with pyproject_path.open("w") as f:
+        tomlkit.dump(data, f)
+
+
+def update_readme(version: str, readme_path: Path) -> None:
+    """Find version in README table and update it."""
+    start = "<!-- START README TABLE -->"
+    end = "<!-- END README TABLE -->"
+
+    with readme_path.open("r") as f:
+        lines = f.readlines()
+
+    in_table = False
+    for i, line in enumerate(lines):
+        if start in line:
+            in_table = True
+        if in_table:
+            if "**Version**" in line:
+                lines[i] = f"| **Version** | {version} ([Changelog](/CHANGELOG.md)) |\n"
+                break
+        if end in line:
+            raise ValueError("**Version** not found in README table.")
+
+    with readme_path.open("w") as f:
+        f.writelines(lines)
+
+
+def main(pyproject_path: Path, readme_path: Path) -> None:
+    version = get_version(pyproject_path)
+    version = Version(version)
+    version = Version(f"{version.major}.{version.minor}.{version.micro + 1}")
+    update_pyproject_version(str(version), pyproject_path)
+    update_readme(str(version), readme_path)
+
+
+if __name__ == "__main__":
+    main(pyproject_path, readme_path)

src/dynaword/dataset_structure.py

@@ -0,0 +1,35 @@
+import logging
+from datetime import date
+from enum import Enum
+
+from pydantic import BaseModel, BeforeValidator
+from typing_extensions import Annotated
+
+logger = logging.getLogger(__name__)
+
+
+def ensure_tuple(created: str | tuple) -> tuple:
+    if isinstance(created, str):
+        return tuple(created.split(", "))
+    return created
+
+
+class SampleSchema(BaseModel):
+    id: str
+    text: str
+    source: str
+    added: date
+    created: Annotated[tuple[date, date], BeforeValidator(ensure_tuple)]
+    token_count: int
+
+
+class ColumnNames(Enum):
+    id = "id"
+    text = "text"
+    source = "source"
+    added = "added"
+    created = "created"
+    token_count = "token_count"
+
+
+COLUMN_ORDER = [col.value for col in ColumnNames]

src/dynaword/datasheet.py

@@ -0,0 +1,307 @@
+import json
+import logging
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from textwrap import dedent
+from typing import Any, Literal, Self, cast
+
+import yaml
+from datasets import Dataset, IterableDataset, load_dataset
+from pydantic import BaseModel, field_validator
+
+from dynaword.descriptive_stats import DescriptiveStatsOverview
+from dynaword.plots.descriptive_statistics_plots import (
+    create_descriptive_statistics_plots,
+)
+from dynaword.typings import DOMAIN, LICENSE, LICENSE_NAMES_MAPPING
+
+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:
+
+- `id` (`str`): An unique identifier for each document.
+- `text`(`str`): The content of the document.
+- `source` (`str`): The source of the document (see [Source Data](#source-data)).
+- `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.
+- `token_count` (`int`): The number of tokens in the sample computed using the Llama 8B tokenizer
+"""
+
+
+def convert_to_human_readable(value: float) -> 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(sample: dict[str, Any], max_str_len: int = 100):
+    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: LICENSE
+    license_name: str | None
+    language: list[Literal["da"]]
+    domains: list[DOMAIN] | None  # None for main readme # TODO: make literal
+    path: Path
+    frontmatter: dict[str, Any]
+    body: str
+
+    # check that licence name is compatible with license
+    @field_validator("license_name")  # type: ignore
+    def check_license_name(cls, v: str | None, values: dict[str, Any]) -> str | None:
+        if v is not None and v in LICENSE_NAMES_MAPPING:
+            if values["license"] != LICENSE_NAMES_MAPPING[v]:
+                raise ValueError(
+                    f"License name '{v}' does not match license '{values['license']}'"
+                )
+        return v
+
+    @property
+    def short_description(self) -> str:
+        short_description = self.get_tag_content(DEFAULT_SECTION_TAGS.short_description)
+        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, sort_keys=False)
+
+    def to_str(self) -> str:
+        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
+        # required to avoid loading .png files for the images/ folder (e.g. for plots) instead of parquet files
+        ignore_dirs = {".venv", "tmp"}  # add more if needed
+
+        parquet_files = [
+            p.as_posix()
+            for p in ds_path.glob("**/*.parquet")
+            if not any(ignored in p.parts for ignored in ignore_dirs)
+        ]
+        ds = load_dataset(
+            ds_path.as_posix(), split="train", data_files=parquet_files, **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("#")
+
+        next_is_end_section = False
+        end_header = None
+        for _header in self.get_headers(levels=list(range(1, level + 1))):
+            if header.strip() == _header.strip():
+                next_is_end_section = True
+                continue
+
+            if next_is_end_section:
+                end_header = _header
+                break
+
+        if next_is_end_section is None:
+            raise ValueError(f"The header '{header}' is not found in the text.")
+
+        start_idx = self.body.find(header)
+        if end_header:
+            end_idx = self.body[start_idx:].find(end_header) + start_idx
+        else:
+            end_idx = len(self.body)
+
+        return start_idx, end_idx
+
+    def get_section_by_header(self, header: str) -> str:
+        s, e = self.get_section_indices_by_header(header)
+        return self.body[s:e]
+
+    def get_headers(self, levels: list[int] = [1, 2, 3, 4]) -> list[str]:
+        def __contains_level(text: str) -> bool:
+            if text.startswith("#"):
+                for level in levels:
+                    if text.startswith("#" * level):
+                        return True
+            return False
+
+        return [line for line in self.body.splitlines() if __contains_level(line)]
+
+    def get_tag_idx(self, tag: str | DEFAULT_SECTION_TAGS) -> tuple[int, int]:
+        if isinstance(tag, Enum):
+            tag = tag.value
+        tag_start = f"<!-- START-{tag} -->"
+        tag_end = f"<!-- END-{tag} -->"
+        start_idx = self.body.find(tag_start)
+        end_idx = self.body.find(tag_end)
+        if end_idx != -1 and start_idx != -1 and start_idx < end_idx:
+            return start_idx, end_idx
+        raise ValueError(f"tag ({tag}) not found in readme")
+
+    def get_tag_content(self, tag: str | DEFAULT_SECTION_TAGS) -> str:
+        if isinstance(tag, Enum):
+            tag = tag.value
+        s, e = self.get_tag_idx(tag=tag)
+        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
+
+        package = (
+            dedent(f"""
+        - **Number of samples**: {convert_to_human_readable(d_stats.number_of_samples)}
+        - **Number of tokens (Llama 3)**: {convert_to_human_readable(d_stats.number_of_tokens)}
+        - **Average document length in tokens (min, max)**: {convert_to_human_readable(d_stats.average_document_length_tokens)} ({convert_to_human_readable(d_stats.min_length_tokens)}, {convert_to_human_readable(d_stats.max_length_tokens)})
+        """).strip()
+            + "\n"
+        )
+
+        return self.replace_tag(
+            package=package,
+            tag=DEFAULT_SECTION_TAGS.desc_stats,
+        )
+
+    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
+        )
+
+    def add_sample_and_description(
+        self, dataset: Dataset | IterableDataset | None = None
+    ) -> str:
+        if dataset is None:
+            dataset = self.get_dataset(streaming=True)
+
+        sample = dataset[0] if isinstance(dataset, Dataset) else next(iter(dataset))
+        return self.replace_tag(
+            package=create_sample_str(sample), tag=DEFAULT_SECTION_TAGS.sample
+        )
+
+    def replace_tag(self, package: str, tag: str | DEFAULT_SECTION_TAGS) -> 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
+        """
+        if isinstance(tag, Enum):
+            tag = tag.value
+        tag_start = f"<!-- START-{tag} -->"
+        tag_end = f"<!-- END-{tag} -->"
+
+        if self.body.count(tag_start) != 1 or self.body.count(tag_end) != 1:
+            raise ValueError(
+                f"The markers ({tag_start} ... {tag_end}) does not appear in the markdown. Markers should appear exactly once in the markdown."
+            )
+
+        start_md, _, remainder = self.body.partition(tag_start)
+        _, _, end_md = remainder.partition(tag_end)
+
+        return f"{start_md}{tag_start}\n{package.strip()}\n{tag_end}{end_md}"
+
+    @staticmethod
+    def get_frontmatter_and_body(file_path: Path) -> tuple[dict[str, Any], str]:
+        with file_path.open("r") as f:
+            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[start_idx_body:]
+        raise ValueError(f"No frontmatter found in file: {file_path}")
+
+    @classmethod
+    def load_from_path(cls, readme_path: Path) -> Self:
+        frontmatter, body = cls.get_frontmatter_and_body(readme_path)
+        return cls(
+            frontmatter=frontmatter,
+            body=body,
+            license=frontmatter["license"],
+            language=frontmatter["language"],
+            pretty_name=frontmatter["pretty_name"],
+            domains=frontmatter["domains"] if "domains" in frontmatter else None,
+            license_name=frontmatter["license_name"]
+            if "license_name" in frontmatter
+            else None,
+            path=readme_path,
+        )
+
+    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:
+            f.write(self.to_str())
+
+
+if __name__ == "__main__":
+    from dynaword.paths import repo_path
+
+    sheet = DataSheet.load_from_path(repo_path / "data" / "dannet" / "dannet.md")
+    ds = sheet.get_dataset()
+
+    sheet.body = sheet.add_descriptive_stats(descriptive_stats=None)
+    sheet.write_to_path()

src/dynaword/descriptive_stats.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+
+from datasets import Dataset
+
+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:
+    """
+    Overview of descriptive statistics for a dataset.
+
+    Attributes:
+        number_of_samples: Total number of samples in the dataset.
+        number_of_tokens: Total number of tokens in the dataset
+        min_length: Minimum document length in tokens.
+        max_length: Maximum document length in tokens.
+        average_document_length: Average document length in tokens.
+    """
+
+    number_of_samples: int
+    number_of_tokens: int
+    min_length_tokens: int
+    max_length_tokens: int
+    number_of_characters: int
+    min_length_characters: int
+    max_length_characters: int
+
+    @property
+    def average_document_length_tokens(self) -> float:
+        return (
+            round(self.number_of_tokens / self.number_of_samples, 2)
+            if self.number_of_samples > 0
+            else 0.0
+        )
+
+    @property
+    def average_document_length_characters(self) -> float:
+        return (
+            round(self.number_of_characters / self.number_of_samples, 2)
+            if self.number_of_samples > 0
+            else 0.0
+        )
+
+    @classmethod
+    def from_disk(cls, path: Path) -> DescriptiveStatsOverview:
+        with path.open("r") as f:
+            data = json.load(f)
+        obj = cls(**data)
+        return obj
+
+    def to_disk(self, path: Path) -> None:
+        with path.with_suffix(".json").open("w") as f:
+            json.dump(self.__dict__, f, indent=2)
+
+    @classmethod
+    def from_dataset(cls, dataset: Dataset) -> DescriptiveStatsOverview:
+        return cls(
+            number_of_samples=len(dataset),
+            number_of_tokens=sum(dataset["token_count"]),
+            min_length_tokens=min(dataset["token_count"]),
+            max_length_tokens=max(dataset["token_count"]),
+            number_of_characters=sum(len(t) for t in dataset["text"]),
+            min_length_characters=min(len(t) for t in dataset["text"]),
+            max_length_characters=max(len(t) for t in dataset["text"]),
+        )
+
+    def __add__(self, other: DescriptiveStatsOverview) -> DescriptiveStatsOverview:
+        if not isinstance(other, DescriptiveStatsOverview):
+            raise TypeError("Can only add DescriptiveStatsOverview objects")
+        return DescriptiveStatsOverview(
+            number_of_samples=self.number_of_samples + other.number_of_samples,
+            number_of_tokens=self.number_of_tokens + other.number_of_tokens,
+            min_length_tokens=min(self.min_length_tokens, other.min_length_tokens),
+            max_length_tokens=max(self.max_length_tokens, other.max_length_tokens),
+            number_of_characters=self.number_of_characters + other.number_of_characters,
+            min_length_characters=min(
+                self.min_length_characters, other.min_length_characters
+            ),
+            max_length_characters=max(
+                self.max_length_characters, other.max_length_characters
+            ),
+        )

src/dynaword/paths.py

@@ -0,0 +1,5 @@
+from pathlib import Path
+
+repo_path = Path(__file__).parent.parent.parent
+pyproject_path = repo_path / "pyproject.toml"
+readme_path = repo_path / "README.md"

src/dynaword/plots/descriptive_statistics_plots.py

@@ -0,0 +1,44 @@
+import logging
+from pathlib import Path
+
+import pandas as pd
+import plotnine as pn
+from datasets import Dataset
+
+logger = logging.getLogger(__name__)
+
+
+def create_descriptive_statistics_plots(
+    dataset: Dataset,
+    save_dir: Path,
+) -> tuple[Path, pn.ggplot]:
+    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)
+    save_path = img_path / "dist_document_length.png"
+    pn.ggsave(
+        plot,
+        save_path,
+        dpi=500,
+        width=10,
+        height=10,
+        units="in",
+        verbose=False,
+    )
+
+    return save_path, plot

src/dynaword/plots/plot_tokens_over_time.py

@@ -0,0 +1,242 @@
+import json
+import logging
+import subprocess
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Tuple
+
+import pandas as pd
+import plotly.graph_objects as go
+
+from dynaword.paths import repo_path
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+def get_file_history(
+    filename: str = "descriptive_stats.json",
+) -> List[Tuple[str, str, str]]:
+    """Get commit history for a file with commit messages"""
+    logger.info(f"Retrieving git history for {filename}")
+
+    cmd = [
+        "git",
+        "log",
+        "--format=%H|%ci|%s",  # commit hash | commit date | subject
+        "--",
+        filename,
+    ]
+
+    try:
+        result = subprocess.run(
+            cmd, capture_output=True, text=True, cwd=repo_path, check=True
+        )
+        commits = []
+
+        for line in result.stdout.strip().split("\n"):
+            if line:
+                parts = line.split("|", 2)  # Split on first 2 pipes only
+                if len(parts) == 3:
+                    commit_hash, date_str, message = parts
+                    commits.append((commit_hash, date_str, message))
+
+        logger.info(f"Found {len(commits)} commits for {filename}")
+        return commits
+
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Failed to get git history: {e}")
+        return []
+
+
+def get_file_at_commit(commit_hash: str, filename: str) -> Optional[Dict[str, Any]]:
+    """Get file content at specific commit"""
+    cmd = ["git", "show", f"{commit_hash}:{filename}"]
+
+    try:
+        result = subprocess.run(
+            cmd, capture_output=True, text=True, cwd=repo_path, check=True
+        )
+        return json.loads(result.stdout)
+    except (subprocess.CalledProcessError, json.JSONDecodeError) as e:
+        logger.warning(f"Failed to parse {filename} at commit {commit_hash[:8]}: {e}")
+        return None
+
+
+def create_token_dataframe(filename: str = "descriptive_stats.json") -> pd.DataFrame:
+    """Create DataFrame with token history from git commits"""
+    logger.info("Building token history dataframe from git commits")
+
+    commits = get_file_history(filename)
+    if not commits:
+        logger.warning("No commits found")
+        return pd.DataFrame()
+
+    data = []
+    for commit_hash, date_str, commit_message in commits:
+        file_data = get_file_at_commit(commit_hash, filename)
+        if file_data and "number_of_tokens" in file_data:
+            try:
+                date = datetime.fromisoformat(date_str.split(" ")[0])
+                data.append(
+                    {
+                        "date": date,
+                        "tokens": file_data["number_of_tokens"],
+                        "samples": file_data.get("number_of_samples", 0),
+                        "avg_length": file_data.get("average_document_length", 0),
+                        "commit": commit_hash,
+                        "commit_short": commit_hash[:8],
+                        "commit_message": commit_message,
+                    }
+                )
+            except ValueError as e:
+                logger.warning(f"Failed to parse date {date_str}: {e}")
+
+    # Convert to DataFrame and sort by date
+    df = pd.DataFrame(data)
+    if df.empty:
+        logger.warning("No valid data found in commits")
+        return df
+
+    df = df.sort_values("date").reset_index(drop=True)
+
+    # Calculate token changes
+    if len(df) > 1:
+        df["token_change"] = df["tokens"].diff()
+
+    logger.info(
+        f"Created dataframe with {len(df)} data points spanning {df['date'].min().date()} to {df['date'].max().date()}"
+    )
+    return df
+
+
+def _format_tokens(value: float) -> str:
+    """Format tokens with human-readable suffixes"""
+    if value >= 1e12:
+        return f"{value / 1e12:.2f}T"
+    elif value >= 1e9:
+        return f"{value / 1e9:.2f}G"
+    elif value >= 1e6:
+        return f"{value / 1e6:.2f}M"
+    elif value >= 1e3:
+        return f"{value / 1e3:.2f}k"
+    else:
+        return f"{value:.0f}"
+
+
+def _create_hover_text(df: pd.DataFrame) -> List[str]:
+    """Create hover text for each data point"""
+    hover_text = []
+    for _, row in df.iterrows():
+        hover_info = (
+            f"Date: {row['date'].strftime('%Y-%m-%d')}<br>"
+            f"Tokens: {_format_tokens(row['tokens'])}<br>"
+        )
+
+        if pd.notna(row.get("token_change")):
+            change_sign = "+" if row["token_change"] >= 0 else ""
+            hover_info += (
+                f"Change: {change_sign}{_format_tokens(abs(row['token_change']))}<br>"
+            )
+
+        hover_info += (
+            f"Samples: {row['samples']:,}<br>"
+            f"Commit: {row['commit_short']}<br>"
+            f"Message: {row['commit_message']}"
+        )
+        hover_text.append(hover_info)
+
+    return hover_text
+
+
+def _add_reference_lines(fig: go.Figure) -> None:
+    """Add reference lines for other Danish corpora"""
+    references = [
+        (300_000_000, "Common Corpus (dan) (Langlais et al., 2025)"),
+        (1_000_000_000, "Danish Gigaword (Derczynski et al., 2021)"),
+    ]
+
+    for y_value, annotation in references:
+        fig.add_hline(
+            y=y_value,
+            line_dash="dash",
+            line_color="gray",
+            line_width=1,
+            annotation_text=annotation,
+            annotation_position="top left",
+            annotation_font_size=12,
+            annotation_font_color="gray",
+        )
+
+
+def plot_tokens_over_time(
+    df: pd.DataFrame, width: int = 600, height: int = 400
+) -> go.Figure:
+    """Plot tokens over time using Plotly with interactive hover info"""
+    hover_text = _create_hover_text(df)
+
+    # Create the plot
+    fig = go.Figure()
+
+    # Add main data line
+    fig.add_trace(
+        go.Scatter(
+            x=df["date"],
+            y=df["tokens"],
+            mode="lines+markers",
+            name="Tokens",
+            line=dict(width=3, color="#DC2626"),  # Saturated red
+            marker=dict(size=5, color="#DC2626"),
+            hovertemplate="%{text}<extra></extra>",
+            text=hover_text,
+        )
+    )
+
+    # Add reference lines
+    _add_reference_lines(fig)
+
+    # Update layout
+    fig.update_layout(
+        title="Number of Tokens Over Time in Danish Dynaword",
+        xaxis_title="Date",
+        yaxis_title="Number of Tokens (Llama 3)",
+        hovermode="closest",
+        width=width,
+        height=height,
+        showlegend=False,
+        plot_bgcolor="rgba(0,0,0,0)",  # Transparent plot background
+        paper_bgcolor="rgba(0,0,0,0)",  # Transparent paper background
+    )
+
+    # Set x-axis and y-axis properties
+    # x_min = df["date"].min() - pd.Timedelta(days=)
+    # x_max = df["date"].max() + pd.Timedelta(days=1)
+
+    # Format y-axis
+    fig.update_yaxes(tickformat=".2s", ticksuffix="")
+    # fig.update_xaxes(range=[x_min, x_max])  # Explicitly set x-axis range
+    return fig
+
+
+def create_tokens_over_time_plot() -> None:
+    """Main function to create DataFrame and plot tokens over time"""
+    df = create_token_dataframe()
+    if not df.empty:
+        logger.info("Generating interactive plot")
+        fig = plot_tokens_over_time(df)
+    else:
+        logger.warning("No data available to plot")
+        return
+
+    save_path = repo_path / "images" / "tokens_over_time.html"
+    save_path_svg = repo_path / "images" / "tokens_over_time.svg"
+
+    save_path.parent.mkdir(parents=True, exist_ok=True)
+    fig.write_html(save_path, include_plotlyjs="cdn")
+    fig.write_image(save_path_svg)
+
+
+if __name__ == "__main__":
+    create_tokens_over_time_plot()

src/dynaword/plots/plots_dataset_size.py

@@ -0,0 +1,134 @@
+import json
+import logging
+from pathlib import Path
+
+import pandas as pd
+import plotly.graph_objects as go
+
+from dynaword.datasheet import DataSheet
+from dynaword.paths import repo_path
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+def _create_descriptive_stats_table(
+    repo_path: Path = repo_path,
+) -> pd.DataFrame:
+    """
+    Create a DataFrame from the descriptive statistics data.
+    """
+    p = (repo_path / "data").glob("**/*descriptive_stats.json")
+
+    data = []
+    for path in p:
+        with path.open("r") as f:
+            package = json.load(f)
+            sheet = DataSheet.load_from_path(path.parent / f"{path.parent.name}.md")
+            package["dataset_name"] = path.parent.name
+            package["pretty_name"] = sheet.pretty_name
+            data.append(package)
+
+    df = pd.DataFrame(data)
+    df["mean_length_tokens"] = df["number_of_tokens"] / df["number_of_samples"]
+    df["mean_length_characters"] = df["number_of_characters"] / df["number_of_samples"]
+    return df
+
+
+def plot_dataset_size(df: pd.DataFrame) -> go.Figure:
+    """Plot dataset size using a range plot with min, max, and mean token lengths."""
+    # Calculate mean token length per document
+    df["mean_length_tokens"] = df["number_of_tokens"] / df["number_of_samples"]
+
+    # Create the range plot
+    fig = go.Figure()
+
+    # Add range bars (from min to max)
+    for i, row in df.iterrows():
+        fig.add_trace(
+            go.Scatter(
+                x=[row["min_length_tokens"], row["max_length_tokens"]],
+                y=[row["dataset_name"], row["dataset_name"]],
+                mode="lines",
+                line=dict(color="lightgray", width=3),
+                showlegend=False,
+                hoverinfo="skip",
+            )
+        )
+
+    # Add min points
+    fig.add_trace(
+        go.Scatter(
+            x=df["min_length_tokens"],
+            y=df["dataset_name"],
+            mode="markers",
+            marker=dict(color="lightblue", size=6, symbol="circle"),
+            name="Min tokens",
+            hovertemplate="<b>%{y}</b><br>Min: %{x:,} tokens<extra></extra>",
+        )
+    )
+
+    # Add max points
+    fig.add_trace(
+        go.Scatter(
+            x=df["max_length_tokens"],
+            y=df["dataset_name"],
+            mode="markers",
+            marker=dict(color="darkred", size=6, symbol="circle"),
+            name="Max tokens",
+            hovertemplate="<b>%{y}</b><br>Max: %{x:,} tokens<extra></extra>",
+        )
+    )
+
+    # Add mean points
+    fig.add_trace(
+        go.Scatter(
+            x=df["mean_length_tokens"],
+            y=df["dataset_name"],
+            mode="markers",
+            marker=dict(color="orange", size=8, symbol="diamond"),
+            name="Mean tokens",
+            hovertemplate="<b>%{y}</b><br>Mean: %{x:,.0f} tokens<extra></extra>",
+        )
+    )
+
+    fig.update_layout(
+        title="Token Length Distribution by Dataset<br><sub>Range (min-max) with mean values</sub>",
+        xaxis_title="Number of Tokens (log scale)",
+        xaxis_type="log",
+        yaxis_title="Dataset",
+        height=len(df["dataset_name"]) * 20,  # Scaling based on number of datasets
+        template="plotly_white",
+        margin=dict(l=120),  # More space for dataset names
+        yaxis=dict(
+            tickmode="array",
+            tickvals=df["dataset_name"],
+            ticktext=df["pretty_name"],
+            categoryorder="array",  # keep dataset order
+            categoryarray=df["dataset_name"].tolist(),
+            range=[-0.5, len(df["dataset_name"]) - 0.5],  # <-- fixes top/bottom padding
+        ),
+    )
+
+    return fig
+
+
+def create_dataset_size_plot() -> None:
+    logger.info("Creating range plot of dataset sizes using `descriptive_stats.json`.")
+    df = _create_descriptive_stats_table()
+    fig = plot_dataset_size(df)
+
+    save_path = repo_path / "images" / "dataset_size_plot.html"
+    save_path_svg = repo_path / "images" / "dataset_size_plot.svg"
+
+    logger.info(f"Saving dataset size plot to {save_path} and {save_path_svg}.")
+    save_path.parent.mkdir(parents=True, exist_ok=True)
+    fig.write_html(save_path)
+    fig.write_image(save_path_svg)
+
+
+if __name__ == "__main__":
+    create_dataset_size_plot()

src/dynaword/process_dataset.py

@@ -0,0 +1,74 @@
+""""""
+
+import logging
+from functools import partial
+from typing import Any
+
+from datasets import Dataset
+from transformers import AutoTokenizer
+
+from dynaword.dataset_structure import COLUMN_ORDER, ColumnNames
+
+logger = logging.getLogger(__name__)
+
+# TODO: Add a step to compute the size categories and update the frontmatter
+
+
+def _tokenize_function(
+    examples: dict[str, Any], tokenizer: AutoTokenizer
+) -> dict[str, Any]:
+    encodings = tokenizer(
+        examples["text"],
+        padding=False,
+        truncation=False,
+        return_length=True,  # much faster, avoids storing all IDs
+    )  # type: ignore
+    return {"token_count": encodings["length"]}
+
+
+def add_token_count(
+    ds: Dataset,
+    tokenizer_name: str = "AI-Sweden-Models/Llama-3-8B-instruct",
+    num_proc: int = 4,
+) -> Dataset:
+    tokenizer = AutoTokenizer.from_pretrained(tokenizer_name, use_fast=True)
+
+    tokenize = partial(_tokenize_function, tokenizer=tokenizer)  # type: ignore
+
+    ds = ds.map(tokenize, batched=True, num_proc=num_proc)
+    return ds
+
+
+def _filter_duplicates(example: dict[str, Any], seen_set: set) -> bool:
+    if example[ColumnNames.text.value] in seen_set:
+        return False
+    seen_set.add(example[ColumnNames.text.value])
+    return True
+
+
+def remove_duplicate_text(ds: Dataset) -> Dataset:
+    logger.info("Removing duplicate texts")
+    seen_texts = set()
+    len_ds = len(ds)
+    ds = ds.filter(partial(_filter_duplicates, seen_set=seen_texts))
+    logger.info(f"Filtered {len_ds - len(ds)} duplicate examples")
+    return ds
+
+
+def _filter_empty(example: dict[str, Any]) -> bool:
+    return len(example[ColumnNames.text.value].strip()) > 0
+
+
+def remove_empty_texts(ds: Dataset, num_proc: int = 4) -> Dataset:
+    logger.info("Removing empty texts")
+    len_ds = len(ds)
+    ds = ds.filter(_filter_empty, num_proc=num_proc)
+    logger.info(f"Filtered {len_ds - len(ds)} empty examples")
+
+    return ds
+
+
+def ensure_column_order(ds: Dataset) -> Dataset:
+    logger.info("Ensuring columns are in the correct order and are present")
+    ds = ds.select_columns(COLUMN_ORDER)
+    return ds

src/dynaword/tables.py

@@ -0,0 +1,212 @@
+from pathlib import Path
+from typing import Literal
+
+import pandas as pd
+
+from dynaword.datasheet import DataSheet, convert_to_human_readable
+from dynaword.paths import repo_path
+
+main_sheet = DataSheet.load_from_path(repo_path / "README.md")
+_datasets = [
+    cfg["config_name"]  # type: ignore
+    for cfg in main_sheet.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
+[CC-BY 4.0]: https://creativecommons.org/licenses/by/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,
+    add_readable_tokens: bool = True,
+    add_total_row: bool = True,
+    add_readme_references: bool = True,
+) -> pd.DataFrame:
+    table = {
+        "Source": [],
+        "Sources": [],
+        "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()
+        main_domain = sheet.domains[0] if sheet.domains else ""
+
+        table["Source"] += [f"{dataset_path.name}"]
+        table["Sources"] += [f"[{dataset_path.name}]"]
+        table["License"] += [f"[{sheet.license_name}]"]
+        table["Domain"] += [main_domain]
+        table["Description"] += [sheet.short_description]
+        table["N. Tokens"] += [desc_stats.number_of_tokens]
+
+    df = pd.DataFrame.from_dict(table)
+    df = df.sort_values("N. Tokens", ascending=False)
+
+    if add_total_row:
+        total_row = {
+            "Source": "**Total**",
+            "Sources": "**Total**",
+            "Domain": "",
+            "License": "",
+            "Description": "",
+            "N. Tokens": sum(table["N. Tokens"]),
+        }
+        df = pd.concat(
+            [
+                df,
+                pd.DataFrame([total_row]),
+            ],
+            ignore_index=True,
+        )
+    if add_readme_references:
+        # replace Source with Sources
+        df["Source"] = df["Sources"]
+        df = df.drop(columns=["Sources"])
+    else:
+        # remove Sources
+        df = df.drop(columns=["Sources"])
+
+    if add_readable_tokens:
+        df["N. Tokens"] = df["N. Tokens"].apply(convert_to_human_readable)
+
+    return df
+
+
+def _get_normalized_license(ds: DataSheet) -> str:
+    non_standard_license_names = {
+        "Apache 2.0": "Other (Attribution required)",
+        "NLOD 2.0": "Other (Attribution required)",
+        "DanNet 1.0": "Other (Attribution required)",
+        "Gutenberg": "Other (Attribution required)",
+        "Danish Copyright Law": "Other (No attribution required)",
+    }
+    if (
+        ds.license_name not in non_standard_license_names
+        and ds.license_name is not None
+    ):
+        return ds.license_name
+    if ds.license_name is None:
+        raise ValueError(
+            f"Datasheet {ds.pretty_name} has no license name specified in the frontmatter."
+        )
+    return non_standard_license_names[ds.license_name]
+
+
+def _get_feature_by_string(
+    datasheet: DataSheet, feature_name: Literal["Domain", "Language", "License"]
+) -> str:
+    """Get a specific feature from the frontmatter."""
+
+    match feature_name:
+        case "Domain":
+            return datasheet.domains[0] if datasheet.domains else "N/A"
+        case "Language":
+            return ", ".join(datasheet.language)
+        case "License":
+            return _get_normalized_license(datasheet)
+        case _:
+            raise ValueError(f"Unknown feature: {feature_name}")
+
+
+def create_grouped_table(
+    group: Literal["Domain", "Language", "License"] = "Domain",
+    repo_path: Path = repo_path,
+    add_readable_tokens: bool = True,
+    add_total_row: bool = True,
+) -> pd.DataFrame:
+    table = {
+        "Sources": [],
+        group: [],
+        "N. Tokens": [],
+    }
+
+    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()
+        feature = _get_feature_by_string(sheet, group)
+
+        table["Sources"] += [f"[{dataset_path.name}]"]
+        table[group] += [feature]
+        table["N. Tokens"] += [desc_stats.number_of_tokens]
+
+    if add_total_row:
+        table["Sources"] += [""]
+        table[group] += ["**Total**"]
+        table["N. Tokens"] += [sum(table["N. Tokens"])]
+
+    df = pd.DataFrame.from_dict(table)
+
+    df = df.groupby(group).agg({"Sources": lambda x: ", ".join(x), "N. Tokens": "sum"})
+
+    df = df.sort_values("N. Tokens", ascending=False)
+
+    df.index.name = group
+    df = df.reset_index()
+
+    # Trick the Total row to be at the bottom.
+    new_index = list(df.index.drop(0)) + [0]
+    df = df.reindex(new_index)
+
+    if add_readable_tokens:
+        df["N. Tokens"] = df["N. Tokens"].apply(convert_to_human_readable)
+
+    return df
+
+
+def create_grouped_table_str(
+    repo_path: Path = repo_path,
+    group: Literal["Domain", "Language", "License"] = "Domain",
+) -> str:
+    table = create_grouped_table(group=group, repo_path=repo_path)
+    readme_references = create_dataset_readme_references()
+    package = f"{table.to_markdown(index=False, maxcolwidths=[None, None, None])}\n\n{readme_references}\n\n"
+    return package
+
+
+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/typings.py

@@ -0,0 +1,27 @@
+from typing import Literal
+
+DOMAIN = Literal[
+    "Books",
+    "Conversation",
+    "Dialect",
+    "Encyclopedic",
+    "Legal",
+    "Medical",
+    "News",
+    "Other",
+    "Readaloud",
+    "Social Media",
+    "Speeches",
+    "Spoken",
+    "Subtitles",
+    "Web",
+]
+
+LICENSE = Literal["cc0-1.0", "other", "cc-by-sa-4.0", "apache-2.0", "cc-by-4.0"]
+
+LICENSE_NAMES_MAPPING = {
+    "cc0-1.0": "CC0",
+    "cc-by-sa-4.0": "CC BY-SA 4.0",
+    "cc-by-4.0": "CC-BY 4.0",
+    "apache-2.0": "Apache 2.0",
+}

src/dynaword/update_descriptive_statistics.py

@@ -0,0 +1,170 @@
+"""
+A simple CLI to updates descriptive statistics on all datasets.
+
+Example use:
+
+    uv run  src/dynaword/update_descriptive_statistics.py --dataset wikisource
+
+"""
+
+import argparse
+import logging
+from pathlib import Path
+from typing import cast
+
+import plotly.express as px
+from datasets import Dataset, load_dataset
+
+from dynaword.datasheet import DataSheet
+from dynaword.descriptive_stats import DescriptiveStatsOverview
+from dynaword.paths import repo_path
+from dynaword.plots.plot_tokens_over_time import create_tokens_over_time_plot
+from dynaword.plots.plots_dataset_size import create_dataset_size_plot
+from dynaword.tables import (
+    create_grouped_table_str,
+    create_overview_table,
+    create_overview_table_str,
+)
+
+logger = logging.getLogger(__name__)
+
+main_sheet = DataSheet.load_from_path(repo_path / "README.md")
+_datasets = [
+    cfg["config_name"]  # type: ignore
+    for cfg in main_sheet.frontmatter["configs"]  # type: ignore
+    if cfg["config_name"] != "default"  # type: ignore
+]
+
+
+logger = logging.getLogger(__name__)
+
+
+def create_domain_distribution_plot(
+    save_dir: Path = repo_path,
+):
+    df = create_overview_table(
+        add_readable_tokens=False, add_total_row=False, add_readme_references=False
+    )
+    fig = px.sunburst(df, path=["Domain", "Source"], values="N. Tokens")
+
+    fig.update_traces(textinfo="label+percent entry")
+    fig.update_layout(title="Dataset Distribution by Domain and Source")
+
+    img_path = save_dir / "images"
+    img_path.mkdir(parents=False, exist_ok=True)
+    save_path = img_path / "domain_distribution.png"
+    fig.write_image(
+        save_path,
+        width=800,
+        height=800,
+        scale=2,
+    )
+
+
+def update_dataset(
+    dataset_name: str,
+    force: bool = False,
+) -> None:
+    dataset_path = (
+        repo_path / "data" / dataset_name if dataset_name != "default" else repo_path
+    )
+
+    if dataset_name == "default":
+        readme_name = "README.md"
+    else:
+        readme_name = f"{dataset_name}.md"
+
+    desc_stats_path = dataset_path / "descriptive_stats.json"
+    markdown_path = dataset_path / readme_name
+
+    if desc_stats_path.exists() and force is False:
+        logger.info(
+            f"descriptive statistics for '{dataset_name}' is already exists (``{desc_stats_path}``), skipping."
+        )
+        return
+
+    logger.info(f"Updating datasheet for: {dataset_name}")
+    sheet = DataSheet.load_from_path(markdown_path)
+
+    if dataset_name != "default":
+        ds = load_dataset(str(repo_path), dataset_name, split="train")
+        ds = cast(Dataset, ds)
+        desc_stats = DescriptiveStatsOverview.from_dataset(ds)
+        sheet.body = sheet.add_dataset_plots(ds, create_plot=True)
+    else:
+        # compute descriptive stats from existing files
+        desc_paths = (repo_path / "data").glob("**/*descriptive_stats.json")
+        _desc_stats = [DescriptiveStatsOverview.from_disk(p) for p in desc_paths]
+        desc_stats = sum(_desc_stats[1:], start=_desc_stats[0])
+    desc_stats.to_disk(desc_stats_path)
+
+    sheet.body = sheet.add_descriptive_stats(descriptive_stats=desc_stats)
+    sheet.body = sheet.add_sample_and_description()
+
+    if dataset_name == "default":
+        logger.info("Updating Overview table")
+        overview_table = create_overview_table_str()
+        sheet.body = sheet.replace_tag(package=overview_table, tag="MAIN TABLE")
+        logger.info("Updating domain table")
+        domain_table = create_grouped_table_str(group="Domain")
+        sheet.body = sheet.replace_tag(package=domain_table, tag="DOMAIN TABLE")
+        logger.info("Updating license table")
+        domain_table = create_grouped_table_str(group="License")
+        sheet.body = sheet.replace_tag(package=domain_table, tag="LICENSE TABLE")
+        create_domain_distribution_plot()
+        create_tokens_over_time_plot()
+        create_dataset_size_plot()
+
+    sheet.write_to_path()
+
+
+def create_parser():
+    parser = argparse.ArgumentParser(
+        description="Calculated descriptive statistics of the datasets in tha data folder"
+    )
+    parser.add_argument(
+        "--dataset",
+        default=None,
+        type=str,
+        help="Use to specify if you only want to compute the statistics from a singular dataset.",
+    )
+    parser.add_argument(
+        "--logging_level",
+        default=20,
+        type=int,
+        help="Sets the logging level. Default to 20 (INFO), other reasonable levels are 10 (DEBUG) and 30 (WARNING).",
+    )
+    parser.add_argument(
+        "--force",
+        type=bool,
+        default=False,
+        action=argparse.BooleanOptionalAction,
+        help="Should the statistics be forcefully recomputed. By default it checks the difference in commit ids.",
+    )
+    return parser
+
+
+def main(
+    dataset: str | None = None,
+    logging_level: int = 20,
+    force: bool = False,
+) -> None:
+    logging.basicConfig(level=logging_level)
+
+    if dataset:
+        update_dataset(dataset, force=force)
+    else:
+        for dataset_name in _datasets:
+            update_dataset(dataset_name, force=force)
+        update_dataset("default", force=force)
+
+
+if __name__ == "__main__":
+    parser = create_parser()
+    args = parser.parse_args()
+
+    main(
+        args.dataset,
+        logging_level=args.logging_level,
+        force=args.force,
+    )

src/tests/conftest.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+from dynaword.datasheet import DataSheet
+
+root_path = Path(__file__).parent.parent.parent
+main_readme = root_path / "README.md"
+
+main_sheet = DataSheet.load_from_path(main_readme)
+
+DATASET_NAMES = [
+    cfg["config_name"]
+    for cfg in main_sheet.frontmatter["configs"]
+    if cfg["config_name"] != "default"
+]

src/tests/test_dataset_schema.py

@@ -0,0 +1,37 @@
+import pytest
+from datasets import load_dataset
+
+from dynaword.dataset_structure import SampleSchema
+from dynaword.paths import repo_path
+
+from .conftest import DATASET_NAMES
+
+
+@pytest.mark.parametrize("dataset_name", DATASET_NAMES)
+def test_sample_schema(dataset_name: str):
+    """Ensure that the dataset samples follow the correct schema"""
+
+    ds = load_dataset(
+        str(repo_path.resolve()), dataset_name, split="train", streaming=True
+    )
+    sample = next(iter(ds))
+    SampleSchema(**sample)
+
+
+@pytest.mark.parametrize("dataset_name", DATASET_NAMES)
+def test_dataset_folder_structure(dataset_name: str):
+    """tests that the dataset folder structure is as follows.
+
+    dataset_name
+    |- dataset_name.md
+    |- dataset_name.parquet
+
+    If there is a python file, there should at least be one called `create.py`, but there can be additional.
+    """
+    path = repo_path / "data" / dataset_name
+
+    assert (path / f"{path.name}.parquet").exists()
+    assert (path / f"{path.name}.md").exists()
+
+    if any(p.name.endswith(".py") for p in path.glob("*")):
+        assert (path / "create.py").exists()

src/tests/test_datasheets.py

@@ -0,0 +1,56 @@
+import pytest
+
+from dynaword.datasheet import DEFAULT_SECTION_TAGS, DataSheet
+from dynaword.paths import repo_path
+
+from .conftest import DATASET_NAMES
+
+
+@pytest.mark.parametrize("dataset_name", DATASET_NAMES)
+def test_datasheet_load(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(  # noqa: F841
+        readme
+    )  # will fail if format is not correct
+
+
+@pytest.mark.parametrize("dataset_name", DATASET_NAMES)
+def test_datasheet_content_tags(dataset_name: str):
+    readme = repo_path / "data" / dataset_name / f"{dataset_name}.md"
+    ds_sheet = DataSheet.load_from_path(readme)
+
+    # ensure tags:
+    tags = [v.value for v in DEFAULT_SECTION_TAGS]
+    for tag in tags:
+        ds_sheet.get_tag_idx(tag)
+
+
+@pytest.mark.parametrize("dataset_name", DATASET_NAMES)
+def test_datasheet_license_info(dataset_name: str):
+    """Ensure that license information is present is license is other"""
+    readme = repo_path / "data" / dataset_name / f"{dataset_name}.md"
+    ds_sheet = DataSheet.load_from_path(readme)
+
+    if ds_sheet.license == "other":  # ensure description of underspecified licenses
+        assert ds_sheet.license_information.strip()
+        assert ds_sheet.license_name
+
+
+@pytest.mark.parametrize("dataset_name", DATASET_NAMES)
+def test_datasheet_required_headings(dataset_name: str):
+    readme = repo_path / "data" / dataset_name / f"{dataset_name}.md"
+    ds_sheet = DataSheet.load_from_path(readme)
+
+    req_h2_headings = ["## Dataset Description", "## Additional Information"]
+    for req_h2 in req_h2_headings:
+        assert ds_sheet.get_section_by_header(req_h2)
+
+
+@pytest.mark.parametrize("dataset_name", DATASET_NAMES)
+def test_domains_in_frontmatter(dataset_name: str):
+    readme = repo_path / "data" / dataset_name / f"{dataset_name}.md"
+    ds_sheet = DataSheet.load_from_path(readme)
+
+    assert ds_sheet.domains, "domains annotations are missing"

src/tests/test_load.py

@@ -0,0 +1,33 @@
+from datasets import load_dataset
+
+from dynaword.datasheet import DataSheet
+from dynaword.paths import repo_path
+
+REMOVED_DATA = [
+    "lexdk"
+]  # data that has been removed due to legal disputes, question about legality, or similar
+
+
+def test_dataset_loads():
+    """Ensures that the dataset can load as intended"""
+    name = str(repo_path.resolve())
+    ds = load_dataset(name, split="train", streaming=True)
+    sample = next(iter(ds))
+    assert isinstance(sample, dict)
+
+
+def test_all_datasets_in_yaml():
+    ds_sheet = DataSheet.load_from_path(repo_path / "README.md")
+
+    ds_names = {
+        cfg["config_name"]
+        for cfg in ds_sheet.frontmatter["configs"]
+        if cfg["config_name"] != "default"
+    }
+
+    data_folder = repo_path / "data"
+    datasets = data_folder.glob("*")
+
+    for dataset in datasets:
+        if dataset.name not in REMOVED_DATA:
+            assert dataset.name in ds_names

src/tests/test_quality/test_duplicates.py

@@ -0,0 +1,25 @@
+from typing import cast
+
+import pytest
+from datasets import Dataset, load_dataset
+
+from dynaword.paths import repo_path
+from ..conftest import DATASET_NAMES
+
+
+@pytest.mark.parametrize("dataset_name", DATASET_NAMES)
+def test_no_within_data_duplicates(dataset_name: str):
+    ds = load_dataset(str(repo_path.resolve()), dataset_name, split="train")
+    ds = cast(Dataset, ds)
+
+    assert len(set(ds["text"])) == len(ds)
+
+
+@pytest.mark.skip(
+    "This tests takes too long to run"
+)  # there seems to be some duplicate across
+def test_no_data_duplicates():
+    ds = load_dataset(str(repo_path.resolve()), split="train")
+    ds = cast(Dataset, ds)
+
+    assert len(set(ds["text"])) == len(ds)

src/tests/test_quality/test_short_texts.py

@@ -0,0 +1,20 @@
+from typing import cast
+
+import pytest
+from datasets import Dataset, load_dataset
+
+from dynaword.paths import repo_path
+
+from ..conftest import DATASET_NAMES
+
+
+@pytest.mark.parametrize("dataset_name", DATASET_NAMES)
+def test_no_one_word_documents(dataset_name: str):
+    ds = load_dataset(str(repo_path.resolve()), dataset_name, split="train")
+    ds = cast(Dataset, ds)
+
+    one_word_docs = ds.filter(lambda x: x["token_count"] <= 1)
+
+    assert len(one_word_docs) == 0, (
+        f"Found {len(one_word_docs)} one-word documents in dataset '{dataset_name}'"
+    )

src/tests/test_unique_ids.py

@@ -0,0 +1,15 @@
+from collections import Counter
+from typing import cast
+
+from datasets import Dataset, load_dataset
+
+from dynaword.paths import repo_path
+
+
+def test_ensure_ids_are_unique():
+    name = str(repo_path.resolve())
+    ds = load_dataset(name, split="train")
+    ds = cast(Dataset, ds)
+    counter = Counter(ds["id"])
+    duplicates = [item for item, count in counter.items() if count > 1]
+    assert len(duplicates) == 0, f"Duplicate IDs found: {duplicates}"

test_results.log

@@ -0,0 +1,15 @@
+============================= test session starts ==============================
+platform darwin -- Python 3.12.0, pytest-9.0.2, pluggy-1.6.0
+rootdir: /Users/au561649/Github/norwegian-dynaword
+configfile: pyproject.toml
+plugins: anyio-4.12.1
+collected 13 items
+
+src/tests/test_dataset_schema.py ..                                      [ 15%]
+src/tests/test_datasheets.py .....                                       [ 53%]
+src/tests/test_load.py ..                                                [ 69%]
+src/tests/test_quality/test_duplicates.py .s                             [ 84%]
+src/tests/test_quality/test_short_texts.py .                             [ 92%]
+src/tests/test_unique_ids.py .                                           [100%]
+
+=================== 12 passed, 1 skipped in 96.50s (0:01:36) ===================