Migrated from GitHub

data/README.md

@@ -0,0 +1,35 @@
+# bbcfw
+
+Exploring the BBC News subset of the FineWeb dataset (via HuggingFaceFW/fineweb's dated subsets on HF),
+originally a Common Crawl dataset. Iterating on a previous use of the C4 dataset [here](https://github.com/lmmx/bbcc4).
+
+## Speed benchmarking
+
+The sample 10BT (14 files, each 2.15GB = 30.1GB, only loading 3 columns: url, text, language)
+
+- Each file takes about 45 seconds
+- There are ~25,000 files in the other ~100 non-sample subsets, which suggests ~13 days estimated processing time.
+
+```
+0it [00:00, ?it/s]Processing hf://datasets/HuggingFaceFW/fineweb/sample/10BT/000_00000.parquet
+1it [00:41, 41.21s/it]Processing hf://datasets/HuggingFaceFW/fineweb/sample/10BT/001_00000.parquet
+2it [01:26, 43.58s/it]Processing hf://datasets/HuggingFaceFW/fineweb/sample/10BT/002_00000.parquet
+3it [02:10, 43.65s/it]Processing hf://datasets/HuggingFaceFW/fineweb/sample/10BT/003_00000.parquet
+4it [02:52, 43.32s/it]Processing hf://datasets/HuggingFaceFW/fineweb/sample/10BT/004_00000.parquet
+5it [03:40, 44.68s/it]Processing hf://datasets/HuggingFaceFW/fineweb/sample/10BT/005_00000.parquet
+6it [04:26, 45.31s/it]Processing hf://datasets/HuggingFaceFW/fineweb/sample/10BT/006_00000.parquet
+7it [05:11, 45.06s/it]Processing hf://datasets/HuggingFaceFW/fineweb/sample/10BT/007_00000.parquet
+8it [05:53, 44.24s/it]Processing hf://datasets/HuggingFaceFW/fineweb/sample/10BT/008_00000.parquet
+9it [06:41, 45.47s/it]Processing hf://datasets/HuggingFaceFW/fineweb/sample/10BT/009_00000.parquet
+10it [07:25, 44.95s/it]Processing hf://datasets/HuggingFaceFW/fineweb/sample/10BT/010_00000.parquet
+11it [08:08, 44.41s/it]Processing hf://datasets/HuggingFaceFW/fineweb/sample/10BT/011_00000.parquet
+12it [09:04, 47.78s/it]Processing hf://datasets/HuggingFaceFW/fineweb/sample/10BT/012_00000.parquet
+13it [09:47, 46.53s/it]Processing hf://datasets/HuggingFaceFW/fineweb/sample/10BT/013_00000.parquet
+14it [10:32, 46.04s/it]Processing hf://datasets/HuggingFaceFW/fineweb/sample/10BT/014_00000.parquet
+15it [10:54, 43.61s/it]
+Creating parquet from Arrow format: 100%|█████████████████████████████████████| 10/10 [00:00<00:00, 120.79ba/s]
+Uploading the dataset shards: 100%|██████████████████████████████████████████████| 1/1 [00:02<00:00,  2.15s/it]
+```
+
+- LazyFrame with `scan_parquet`/`sink_parquet` seems to make it marginally faster (but not tested
+  extensively), I decided to use it regardless as it should reduce the memory load.

data/dataset_card.md

@@ -0,0 +1,94 @@
+---
+...TBC...
+...
+license: odc-by
+language:
+- en
+pretty_name: BBC News from FineWeb
+size_categories:
+- 10K<n<100K
+---
+
+# Dataset Card for BBC News from FineWeb
+
+This dataset provides a filtered subset of BBC News articles from the realnewslike subset of the FineWeb dataset, containing approximately 77k articles from BBC News domains.
+
+## Dataset Details
+
+### Dataset Description
+
+- **Curated by:** Louis Maddox (@permutans on HuggingFace and X/Twitter)
+- **License:** ODC-BY (inherited from FineWeb)
+- **Language:** English
+
+### Dataset Sources
+- **Repository:** https://huggingface.co/datasets/permutans/fineweb-bbc-news
+- **Source Dataset:** HuggingFaceFW/fineweb
+- **Paper:** https://arxiv.org/abs/2406.17557 (FineWeb paper)
+
+## Uses
+
+### Direct Use
+Suitable for text analysis and NLP tasks focused on news content, particularly when working with BBC News articles. The dataset provides cleaned article text without metadata like bylines or publication dates.
+
+### Out-of-Scope Use
+This dataset should not be used as a comprehensive archive of BBC News content, as it represents only articles captured in FineWeb's crawl (from CommonCrawl between 2013-2024). It should not be assumed to contain all articles from any given time period.
+
+## Dataset Structure
+
+### Data Instances
+Example format:
+```python
+{
+    'url': 'news.bbc.co.uk/news/article-path',
+    'text': 'Article content...'
+}
+```
+
+### Data Fields
+- `url`: URL of the article with query parameters removed 
+- `text`: Full article text content
+
+### Data Statistics
+- Contains approximately 77k articles
+- No validation split in current version
+
+## Dataset Creation
+
+### Curation Rationale
+Created to provide an easily accessible dataset of BBC news articles while offering a focused view into the FineWeb dataset's coverage of major news sources. Enables analysis of FineWeb's completeness and motivates investigation of alternative data acquisition methods.
+
+### Source Data
+#### Data Collection and Processing
+- Filtered from FineWeb's dated subsets (i.e. not default subset nor sample subsets)
+- Limited to domains: news.bbc.co.uk, www.bbc.co.uk/news, www.bbc.com/news
+- URL cleaning: removed query parameters
+- Regional news content excluded due to sparse coverage in source data
+- No modifications to article text content
+
+#### Personal and Sensitive Information
+Article texts contain only the main content body, without bylines or metadata.
+
+## Bias, Risks, and Limitations
+
+- No validation split in current version
+- Original publication dates not available (FineWeb timestamps were crawl dates)
+- Section/index pages not yet filtered out from article pages
+- Regional news content explicitly excluded due to sparse coverage
+- Relationship between news.bbc.co.uk and bbc.co.uk/news domains needs investigation
+- Coverage may be incomplete compared to full BBC News archive
+
+### Recommendations
+Users should be aware that this represents a subset of BBC News content which appears to be from around 2019 and earlier. For applications requiring comprehensive coverage or accurate publication dates, additional data sources should be considered.
+
+## Future Directions
+- Potential expansion using fineweb dataset for more recent content
+- Addition of publication dates through targeted crawling
+- Filtering to distinguish between section pages and article pages
+- Creation of validation split
+
+## Citation
+Please cite the original FineWeb dataset when using this data. A reference to this one would be welcome but not necessary, I consider this a derivative work.
+
+## Dataset Card Authors
+Louis Maddox (@permutans)

data/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+authors = [
+    { name = "Louis Maddox", email = "[email protected]" },
+]
+name = "bbcfw"
+version = "0.1.0"
+description = "BBC News specific FineWeb dataset processing"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "datasets>=3.2.0",
+    "huggingface-hub>=0.27.0",
+    "polars>=1.19.0",
+    "tqdm>=4.67.1",
+]
+
+[build-system]
+requires = ["pdm-backend"]
+build-backend = "pdm.backend"
+
+[project.license]
+text = "MIT"
+

data/src/bbcfw/core/caching.py

@@ -0,0 +1,20 @@
+import base64
+import tempfile
+from pathlib import Path
+
+
+def cache_name(url: str) -> str:
+    return base64.urlsafe_b64encode(url.encode()).decode().rstrip("=") + ".parquet"
+
+
+def make_cache_path(url: str, cache_dir: Path) -> Path:
+    return cache_dir / cache_name(url=url)
+
+
+def mktemp_cache_dir(id_path: str) -> Path:
+    """Make a temporary directory (deleted upon reboot, so short-term persistent).
+    `id_path` is a path that may contain slashes which will be turned to snake case.
+    """
+    cache_dir = Path(tempfile.gettempdir()) / id_path.replace("/", "_")
+    cache_dir.mkdir(exist_ok=True)
+    return cache_dir

data/src/bbcfw/core/configs.py

@@ -0,0 +1,41 @@
+from functools import partial
+
+import polars as pl
+from datasets import load_dataset_builder
+from huggingface_hub import list_repo_files
+
+from bbcfw.core.caching import make_cache_path, mktemp_cache_dir
+
+
+def map_file_configs(dataset_id: str) -> pl.DataFrame:
+    """Map every file to a config (subset)."""
+    builder_configs = dict(load_dataset_builder(dataset_id).builder_configs)
+    del builder_configs["default"]  # Overlaps data/* configs, the rest are all disjoint
+    # Check that there's only 1 split per config (the train split), with 1 path pattern
+    assert set(len(v.data_files) for v in builder_configs.values()) == {1}
+    assert set(len(v.data_files["train"]) for v in builder_configs.values()) == {1}
+    cfg2path = pl.DataFrame(
+        [
+            {
+                "config_name": cfg_name,
+                "path": builder_configs[cfg_name].data_files["train"][0],
+            }
+            for cfg_name in builder_configs
+        ]
+    ).with_columns(pl.col("path").str.strip_suffix("/*"))
+    source_files = (
+        (
+            pl.DataFrame(
+                {"name": pl.Series(list_repo_files(dataset_id, repo_type="dataset"))}
+            )
+            .with_columns(
+                # Keep only filenames which are 2 levels deep (2nd subpath = the config name)
+                path=pl.col("name").str.extract(r"([^/]*/[^/]*)/"),
+            )
+            .drop_nulls()
+            .sort("name")
+        )
+        .join(cfg2path, on="path")
+        .drop("path")
+    )
+    return source_files

data/src/bbcfw/core/filters.py

@@ -0,0 +1,3 @@
+domain_capture = r"https?://([^/?]+)"
+subpage_capture = r"https?://[^/]+(\/[^/?]+\/)"  # Include pre/suffix slashes
+domain_match = r"^(news\.bbc\.co\.uk|www\.bbc\.co\.uk|www\.bbc\.com)$"

data/src/bbcfw/main.py

@@ -0,0 +1,126 @@
+from functools import partial
+from pathlib import Path
+
+import polars as pl
+from datasets import Dataset, get_dataset_config_names, load_dataset_builder
+from datasets.exceptions import DatasetNotFoundError
+from huggingface_hub import login
+from tqdm import tqdm
+
+from bbcfw.core.caching import make_cache_path, mktemp_cache_dir
+from bbcfw.core.configs import map_file_configs
+from bbcfw.core.filters import domain_capture, domain_match, subpage_capture
+
+# 1) Log into HuggingFace, name the datasets we'll ingest and produce
+
+login(new_session=False)  # Will prompt for your token or use cached token
+
+dataset_id = "HuggingFaceFW/fineweb"
+dataset_id_slug = dataset_id.replace("/", "_")
+username = "permutans"
+result_dataset_name = "fineweb-bbc-news"
+result_dataset_id = f"{username}/{result_dataset_name}"
+
+# 2) Make a directory to cache our transformations of the entire dataset (all subsets)
+
+cache_dir = mktemp_cache_dir(id_path=dataset_id)
+dataset_cache_path = partial(make_cache_path, cache_dir=cache_dir)
+
+parquet_cache_names = cache_dir / f"{dataset_id_slug}_filenames.parquet"
+
+if parquet_cache_names.exists():
+    source_files = pl.read_parquet(parquet_cache_names)
+else:
+    source_files = map_file_configs(dataset_id=dataset_id)
+    source_files.write_parquet(parquet_cache_names)
+
+fwnews_features = {feat_name: pl.String for feat_name in "url text".split()}
+aggregator = pl.DataFrame(schema=fwnews_features)
+
+domain_col = pl.col("url").str.extract(domain_capture)
+path_col = pl.col("url").str.extract(subpage_capture)
+
+config_names = source_files["config_name"].unique().sort()
+
+
+def ds_subset_exists(dataset_id: str, subset_name: str) -> bool:
+    """Check that the dataset exists, and if so whether the config name is in it."""
+    try:
+        configs = get_dataset_config_names(dataset_id)
+    except DatasetNotFoundError:
+        print(f"The dataset {dataset_id} was not found.")
+        return False
+    else:
+        return subset_name in list(configs)
+
+
+def process_all_subsets(reverse: bool=False):
+    for subset_name in tqdm(config_names[::-1] if reverse else config_names):
+        try:
+            # Skip any existing subsets entirely
+            if ds_subset_exists(dataset_id=result_dataset_id, subset_name=subset_name):
+                print(f"Skipping {subset_name} as it exists")
+                continue
+            else:
+                print(f"The subset {subset_name} doesn't exist, creating it")
+            hf_urls = source_files.filter(pl.col("config_name") == subset_name).select(
+                url=f"hf://datasets/{dataset_id}/" + pl.col("name")
+            )
+            pq_caches = []
+
+            def process_subset_chunk(source_url: str) -> Path:
+                parquet_cache_chunk = dataset_cache_path(source_url)
+                if parquet_cache_chunk.exists():
+                    try:
+                        news_df = pl.read_parquet(parquet_cache_chunk)
+                    except:
+                        print(f"Failed to read {parquet_cache_chunk}")
+                        raise
+                else:
+                    print(f"\nProcessing {source_url}")
+                    # Drop query parameters if ? in URL, drop any non-BBC News domain URLs
+                    news_df = (
+                        pl.scan_parquet(source_url, parallel="prefiltered")
+                        .select("url", "text", "language")
+                        .filter(pl.col("language") == "en")
+                        .select(pl.col("url").str.extract(r"([^?]+)"), "text")
+                        .filter(
+                            domain_col.str.contains(domain_match),
+                            ~pl.col("url").str.contains(
+                                r"https?://[^/]+\/\?"
+                            ),  # Path is not `/?`
+                        )
+                        .filter(
+                            domain_col.str.contains("news").or_(path_col == "/news/")
+                        )
+                    )
+                    news_df.sink_parquet(parquet_cache_chunk)
+                return parquet_cache_chunk
+
+            for url in tqdm(list(hf_urls["url"])):
+                parquet_cache_chunk = process_subset_chunk(url)
+                pq_caches.append(parquet_cache_chunk)
+
+            # Reload once all parts completed and upload
+            aggregator = pl.read_parquet(pq_caches)
+
+            news_data = aggregator.to_dict(as_series=False)
+            news_dataset = Dataset.from_dict(news_data)
+            news_dataset.push_to_hub(
+                result_dataset_id,
+                config_name=subset_name,
+                private=False,
+            )
+        except KeyboardInterrupt:
+            print("\nGracefully shutting down - current subset was not completed")
+            return  # Exit cleanly
+        except Exception as e:
+            print(f"\nError processing subset {subset_name}: {str(e)}")
+            continue  # Skip to next subset
+
+
+if __name__ == "__main__":
+    try:
+        process_all_subsets()
+    except KeyboardInterrupt:
+        print("\nShutting down...")

data/src/bbcfw/old/bbc_news_main_subpath_only.py

@@ -0,0 +1,76 @@
+from pprint import pprint
+import tempfile
+
+from pathlib import Path
+import polars as pl
+from huggingface_hub import hf_hub_url, list_repo_files
+from tqdm import tqdm
+import base64
+from datasets import Dataset
+from huggingface_hub import login
+
+login(new_session=False)  # Will prompt for your token or use cached token
+
+cache_dir = Path(tempfile.gettempdir()) / "allenai_c4"
+cache_dir.mkdir(exist_ok=True)
+
+def cache_name(url: str) -> str:
+    return base64.urlsafe_b64encode(url.encode()).decode().rstrip("=") + ".parquet"
+
+def cache_path(url: str, cache_dir=cache_dir) -> Path:
+    return cache_dir / cache_name(url=url)
+
+parquet_cache_names = cache_dir / "realnewslike_filenames.parquet"
+if parquet_cache_names.exists():
+    news_files = pl.read_parquet(parquet_cache_names)["filename"]
+else:
+    file_names = pl.Series(list_repo_files("allenai/c4", repo_type="dataset"))
+    # Take all splits of the realnewslike subset (513 files)
+    news_files = file_names.filter(
+        file_names.str.starts_with("realnewslike/") & file_names.str.ends_with(".json.gz"),
+    ).str.strip_prefix("realnewslike/")
+    pl.DataFrame({"filename": news_files}).write_parquet(parquet_cache_names)
+
+c4n_features = {"url": pl.String, "text": pl.String}
+aggregator = pl.DataFrame(schema=c4n_features)
+
+domain_capture = r"https?://([^/?]+)"
+subpage_capture = r"https?://[^/]+(\/[^/?]+\/)"  # Include pre/suffix slashes
+domain_match = r"^(news\.bbc\.co\.uk|www\.bbc\.co\.uk|www\.bbc\.com)$"
+domain_col = pl.col("url").str.extract(domain_capture)
+path_col = pl.col("url").str.extract(subpage_capture)
+
+hf_urls = [
+    hf_hub_url(
+        repo_id="allenai/c4",
+        filename=filename,
+        subfolder="realnewslike",
+        repo_type="dataset",
+    )
+    for filename in news_files
+]
+pq_caches = list(map(cache_path, hf_urls))
+
+for json_url, parquet_cache_chunk in tqdm(zip(hf_urls, pq_caches)):
+    if parquet_cache_chunk.exists():
+        news_df = pl.read_parquet(parquet_cache_chunk)
+    else:
+        print(f"Processing {json_url}")
+        df = (
+            pl.read_ndjson(json_url, schema=c4n_features)
+            .with_columns(pl.col("url").str.extract(r"([^?]+)"))
+            .filter(
+                domain_col.str.contains(domain_match),
+                ~pl.col("url").str.contains(r"https?://[^/]+\/\?"),  # Path is not `/?`
+            )
+        )
+        # Just match the "/news/" path here
+        news_df = df.filter(domain_col.str.contains('news').or_(path_col == "/news/"))
+        news_df.write_parquet(parquet_cache_chunk)
+
+# Reload once all parts completed and upload
+aggregator = pl.read_parquet(pq_caches)
+
+news_data = aggregator.to_dict(as_series=False)
+news_dataset = Dataset.from_dict(news_data)
+news_dataset.push_to_hub("permutans/c4-bbc-news", config_name="realnewslike-bbc-news", private=False)

data/src/bbcfw/old/bbc_news_urls.py

@@ -0,0 +1,98 @@
+from pprint import pprint
+
+import polars as pl
+from huggingface_hub import hf_hub_url, list_repo_files
+from tqdm import tqdm
+
+file_names = pl.Series(list_repo_files("allenai/c4", repo_type="dataset"))
+# Take all splits of the realnewslike subset (513 files)
+news_files = file_names.filter(
+    file_names.str.starts_with("realnewslike/") & file_names.str.ends_with(".json.gz"),
+).str.strip_prefix("realnewslike/")
+
+c4n_features = {"url": pl.String, "text": pl.String}
+aggregator = pl.DataFrame(schema=c4n_features)
+
+domain_capture = r"https?://([^/?]+)"
+# subpage_capture = r"https?://[^/]+/([^/?]+)"
+subpage_capture = r"https?://[^/]+(\/[^/?]+\/)"  # Include pre/suffix slashes
+url_match = r"^(news\.bbc\.co\.uk|www\.bbc\.co\.uk|www\.bbc\.com)$"
+news_subpages = ["news"]  # Blogs are the 2nd largest category but still far smaller
+regions = [
+    "berkshire",
+    "birmingham",
+    "blackcountry",
+    "bradford",
+    "bristol",
+    "cambridgeshire",
+    "chelsea",
+    "cornwall",
+    "coventry",
+    "cumbria",
+    "derby",
+    "devon",
+    "dorset",
+    "england",
+    "essex",
+    "gloucestershire",
+    "guernsey",
+    "hampshire",
+    "herefordandworcester",
+    "humber",
+    "isleofman",
+    "jersey",
+    "kent",
+    "lancashire",
+    "leeds",
+    "leicester",
+    "lincolnshire",
+    "liverpool",
+    "london",
+    "manchester",
+    "norfolk",
+    "northamptonshire",
+    "northernireland",
+    "nottingham",
+    "oxford",
+    "readingandleeds",
+    "scotland",
+    "shropshire",
+    "somerset",
+    "southampton",
+    "southyorkshire",
+    "stoke",
+    "suffolk",
+    "tees",
+    "tyne",
+    "wales",
+    "wiltshire",
+]
+allowed_subpages = pl.DataFrame({"path": map("/{}/".format, news_subpages + regions)})
+path_col = pl.col("url").str.extract(subpage_capture).alias("path")
+
+for filename in tqdm(news_files):
+    json_url = hf_hub_url(
+        repo_id="allenai/c4",
+        filename=filename,
+        subfolder="realnewslike",
+        repo_type="dataset",
+    )
+    print(f"Processing {json_url}")
+    df = pl.read_ndjson(json_url, schema=c4n_features).filter(
+        pl.col("url").str.extract(domain_capture).str.contains(url_match),
+        ~pl.col("url").str.contains(r"https?://[^/]+\/\?"),  # Path is a ?
+    )
+    news_df = (
+        df.with_columns(path_col)
+        .sort("path")
+        .join(allowed_subpages, on="path")
+        .drop("path")
+    )
+    aggregator = pl.concat([aggregator, news_df])
+    print(aggregator)
+
+with pl.Config() as cfg:
+    cfg.set_tbl_rows(-1)
+    aggregator.with_columns(path_col)["path"].value_counts().sort(
+        "count", descending=True
+    ).with_row_index().pipe(print)

data/src/bbcfw/old/bbc_urls.py

@@ -0,0 +1,36 @@
+from pprint import pprint
+
+import polars as pl
+from huggingface_hub import hf_hub_url, list_repo_files
+from tqdm import tqdm
+
+file_names = pl.Series(list_repo_files("allenai/c4", repo_type="dataset"))
+# Take all splits of the realnewslike subset (513 files)
+news_files = file_names.filter(
+    file_names.str.starts_with("realnewslike/") & file_names.str.ends_with(".json.gz"),
+).str.strip_prefix("realnewslike/")
+
+c4n_features = {"url": pl.String, "text": pl.String}
+aggregator = pl.DataFrame(schema=c4n_features)
+
+domain_capture = r"https?://([^/?]+)"
+url_match = r"^(news\.bbc\.co\.uk|www\.bbc\.co\.uk|www\.bbc\.com)$"
+
+for filename in tqdm(news_files):
+    json_url = hf_hub_url(
+        repo_id="allenai/c4",
+        filename=filename,
+        subfolder="realnewslike",
+        repo_type="dataset",
+    )
+    print(f"Processing {json_url}")
+    df = pl.read_ndjson(json_url, schema=c4n_features).filter(
+        pl.col("url").str.extract(domain_capture).str.contains(url_match),
+        ~pl.col("url").str.contains("/sport/"),
+    )
+    aggregator = pl.concat([aggregator, df])
+    print(aggregator)
+
+# Print all domains
+print("Domains:", end=" ")
+pprint(aggregator.sort("url")["url"].str.extract(domain_capture).unique().to_list())

data/src/bbcfw/old/compare_dataset.py

@@ -0,0 +1,8 @@
+from datasets import Dataset
+from huggingface_hub import login
+
+login(new_session=False)  # Will prompt for your token or use cached token
+
+dataset.load_from_hub(
+    "permutans/bbc-news-dataset", config_name="2025-04", private=False
+)

data/src/bbcfw/old/date_top_tail.py

@@ -0,0 +1,22 @@
+import polars as pl
+from huggingface_hub import hf_hub_url, list_repo_files
+from tqdm import tqdm
+
+file_names = pl.Series(list_repo_files("allenai/c4", repo_type="dataset"))
+# Take all splits of the realnewslike subset (513 files)
+news_files = file_names.filter(
+    file_names.str.starts_with("realnewslike/") & file_names.str.ends_with(".json.gz"),
+).str.strip_prefix("realnewslike/")
+
+features = {"timestamp": pl.Datetime, "url": pl.String}
+aggregator = pl.DataFrame(schema=features)
+for filename in tqdm(news_files):
+    json_url = hf_hub_url(
+        repo_id="allenai/c4",
+        filename=filename,
+        subfolder="realnewslike",
+        repo_type="dataset",
+    )
+    df = pl.read_ndjson(json_url, schema=features).sort("timestamp")
+    aggregator = pl.concat([aggregator, df.head(1), df.tail(1)])
+    print(aggregator.shape)

data/src/bbcfw/old/date_year_agg.py

@@ -0,0 +1,27 @@
+import polars as pl
+from huggingface_hub import hf_hub_url, list_repo_files
+from tqdm import tqdm
+
+file_names = pl.Series(list_repo_files("allenai/c4", repo_type="dataset"))
+# Take all splits of the realnewslike subset (513 files)
+news_files = file_names.filter(
+    file_names.str.starts_with("realnewslike/") & file_names.str.ends_with(".json.gz"),
+).str.strip_prefix("realnewslike/")
+
+c4n_features = {"timestamp": pl.Datetime, "url": pl.String}
+aggregator = pl.DataFrame()
+for filename in tqdm(news_files):
+    json_url = hf_hub_url(
+        repo_id="allenai/c4",
+        filename=filename,
+        subfolder="realnewslike",
+        repo_type="dataset",
+    )
+    print(f"Processing {json_url}")
+    df = pl.read_ndjson(json_url, schema=c4n_features).sort("timestamp")
+    yearly = df.group_by(pl.col("timestamp").dt.year()).agg(
+        pl.count("url").alias("count")
+    )
+    y_pivot = pl.DataFrame({str(year): count for year, count in yearly.rows()})
+    aggregator = pl.concat([aggregator, y_pivot], how="diagonal").sum()
+    print(aggregator)

data/src/bbcfw/old/delete_dataset.py

@@ -0,0 +1,3 @@
+import huggingface_hub
+
+huggingface_hub.delete_repo(repo_id="permutans/fineweb-bbc-news", repo_type="dataset")

data/src/bbcfw/old/load_dataframe_parquet.py

@@ -0,0 +1,6 @@
+import polars as pl
+
+df = pl.read_parquet(
+    "hf://datasets/allenai/c4@~parquet/realnewslike/partial-train/*.parquet",
+    columns=["timestamp", "url"],
+)

data/src/bbcfw/old/upload_dataset.py

@@ -0,0 +1,33 @@
+from datasets import Dataset
+from huggingface_hub import login
+
+login(new_session=False)  # Will prompt for your token or use cached token
+
+# Sample BBC news articles (replace with your actual data)
+news_data = {
+    "text": [
+        "BBC article content here...",
+        "Another BBC article...",
+        "And one more BBC article...",
+    ],
+    "title": [
+        "1st BBC Article",
+        "2nd BBC Article",
+        "3rd BBC Article",
+    ],
+    "date": [
+        "2025-01-04",
+        "2025-01-04",
+        "2025-01-01",
+    ],
+    "url": [
+        "https://bbc.co.uk/news/1",
+        "https://bbc.co.uk/news/2",
+        "https://bbc.co.uk/news/3",
+    ],
+}
+
+dataset = Dataset.from_dict(news_data)
+dataset.push_to_hub(
+    "permutans/bbc-news-dataset-test", config_name="2025-01", private=False
+)