Upload 9 files

.gitattributes

@@ -1,60 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.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
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
 *.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,156 @@
 ---
 license: odc-by
+language:
+- pt
+pretty_name: Corpus PT-BR v2
+tags:
+- portuguese
+- pt-br
+- brazilian-portuguese
+- brasil
+- português
+- nlp
+- llm
+- pretraining
+- fine-tuning
+- text-generation
+- synthetic-data
+- corpus
+- parquet
+task_categories:
+- text-generation
+- fill-mask
+- text-classification
+size_categories:
+- 1M<n<10M
 ---
+
+# Corpus PT-BR v2
+
+Um corpus em Portugues Brasileiro voltado para pre-treinamento, continuacao de pre-treinamento e fine-tuning de LLMs. Esta versao mantem a base e o pipeline geral do `Madras1/corpus-ptbr-v1`, com uma expansao adicional da camada sintetica gerada principalmente por modelos Mistral.
+
+## O que mudou na v2
+
+A v2 preserva o desenho da v1 e adiciona um novo bloco sintetico local:
+
+| Componente novo | Valor |
+|---|---:|
+| Documentos sinteticos adicionados | 371,002 |
+| Palavras adicionadas | 590,143,768 |
+| Tokens estimados adicionados | ~767,186,898 |
+| Tamanho JSONL local original | ~4.01 GB |
+| Tamanho Parquet do incremento | ~1.53 GB |
+| Shards Parquet novos | 4 |
+| Provider principal | Mistral |
+| Modelos principais | `mistral-small-latest`, `mistral-medium-latest` |
+
+## Estatisticas estimadas
+
+As estatisticas abaixo combinam os numeros publicos da v1 com o novo bloco sintetico local convertido para Parquet.
+
+| Metrica | Valor |
+|---|---:|
+| Total de documentos | ~8,770,859 |
+| Total de palavras | ~5.43B |
+| Tokens estimados | ~7.06B |
+| Idioma | Portugues Brasileiro (`pt-br`) |
+| Licenca | ODC-By 1.0 |
+
+### Subsets
+
+| Subset | Documentos | Palavras | Tokens estimados |
+|---|---:|---:|---:|
+| `real` | 6,813,702 | ~4.10B | ~5.33B |
+| `synthetic` | ~1,957,157 | ~1.33B | ~1.73B |
+
+## Fontes
+
+### Subset `real`
+
+Dados de pretraining limpos e filtrados de fontes publicas, herdados da v1:
+
+| Fonte | Documentos | Descricao |
+|---|---:|---|
+| `c4_pt` | 3,070,868 | Common Crawl (C4), subset em portugues |
+| `fineweb2_pt` | 3,742,834 | FineWeb2 filtrado para portugues |
+
+### Subset `synthetic`
+
+A v2 inclui todo o conjunto sintetico da v1 e adiciona 371,002 documentos gerados localmente em abril/maio de 2026.
+
+Novo bloco v2:
+
+| Provider/model | Documentos |
+|---|---:|
+| `mistral-small-latest` | 288,189 |
+| `mistral-medium-latest` | 74,407 |
+| `nvidia/nemotron-3-super-120b-a12b:free` | 8,406 |
+
+Nos shards v2, o campo `source` representa a origem sintetica normalizada:
+
+| `source` | Significado |
+|---|---|
+| `v2_synthetic_mistral_small_latest` | Texto sintetico gerado com Mistral Small |
+| `v2_synthetic_mistral_medium_latest` | Texto sintetico gerado com Mistral Medium |
+| `v2_synthetic_openrouter_nvidia_nemotron_3_super_120b_a12b_free` | Texto sintetico gerado via OpenRouter/Nemotron |
+
+## Schema
+
+O schema principal foi mantido compativel com a v1 para permitir carregamento como um unico split `train`.
+
+| Campo | Tipo | Descricao |
+|---|---|---|
+| `text` | `string` | Conteudo do documento |
+| `source` | `string` | Fonte/origem normalizada |
+| `subset` | `string` | `real` ou `synthetic` |
+| `word_count` | `int32` | Contagem de palavras |
+| `char_count` | `int32` | Contagem de caracteres |
+| `language` | `string` | `pt-br` |
+
+## Como usar
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("Madras1/corpus-ptbr-v2", split="train", streaming=True)
+
+for row in ds.take(1):
+    print(row["text"][:500])
+```
+
+Para filtrar apenas a camada sintetica:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("Madras1/corpus-ptbr-v2", split="train", streaming=True)
+synthetic = (row for row in ds if row["subset"] == "synthetic")
+```
+
+## Limitações
+
+- Dados sinteticos podem conter alucinacoes factuais.
+- O subset real herda vieses, ruidos e limitacoes das fontes originais.
+- O corpus nao deve ser tratado como fonte factual autoritativa.
+- Estimativas de tokens usam fator aproximado de `1.3x` sobre contagem de palavras.
+- A v2 aumenta a proporcao de texto sintetico; para pre-treinamento mais conservador, recomenda-se misturar pesos por `subset` e `source`.
+
+## Licenca e termos
+
+O Corpus PT-BR v2 e distribuido sob ODC-By 1.0, seguindo a base da v1. O subset sintetico contem outputs de modelos de linguagem e deve ser usado com atencao aos termos dos provedores usados na geracao. Segundo a documentacao publica da Mistral AI, usuarios possuem seus outputs ate onde permitido pela lei aplicavel, mas continuam responsaveis por avaliar precisao, adequacao e direitos de uso do conteudo gerado.
+
+## Citacao
+
+```bibtex
+@dataset{madras1_corpus_ptbr_v2,
+  title = {Corpus PT-BR v2},
+  author = {Gabriel Yogi},
+  year = {2026},
+  publisher = {Hugging Face},
+  url = {https://huggingface.co/datasets/Madras1/corpus-ptbr-v2}
+}
+```
+
+## Autor
+
+Gabriel Yogi (MadrasLe) - Hugging Face

data/v2-synthetic-00000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34f15ad8c9f4c66d952d7d95d634f44f195056c2a86b3e8ab98219be427dbb87
+size 421327562

data/v2-synthetic-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:17b5dcc6df907b86ef0b47f31d8b84bc33e06839f9bdba08239d2f0e651468a1
+size 424618319

data/v2-synthetic-00002.parquet

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

data/v2-synthetic-00003.parquet

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

manifests/v2_synthetic_addition_manifest.json

@@ -0,0 +1,125 @@
+{
+  "created_at": "2026-05-24T18:36:21.998022+00:00",
+  "input_dir": "CORPUS",
+  "output_dir": "corpus-ptbr-v2/data",
+  "schema": [
+    {
+      "name": "text",
+      "type": "string"
+    },
+    {
+      "name": "source",
+      "type": "string"
+    },
+    {
+      "name": "subset",
+      "type": "string"
+    },
+    {
+      "name": "word_count",
+      "type": "int32"
+    },
+    {
+      "name": "char_count",
+      "type": "int32"
+    },
+    {
+      "name": "language",
+      "type": "string"
+    }
+  ],
+  "settings": {
+    "rows_per_shard": 100000,
+    "min_words": 1,
+    "max_words": 0,
+    "limit": 0,
+    "compression": "zstd",
+    "dedupe_exact_text": true
+  },
+  "counts": {
+    "jsonl_files": 35,
+    "records_seen": 371002,
+    "records_written": 371002,
+    "records_skipped_empty": 0,
+    "records_skipped_parse_error": 0,
+    "records_skipped_duplicate_text": 0,
+    "records_skipped_too_short": 0,
+    "records_skipped_too_long": 0,
+    "total_words": 590143768,
+    "total_chars": 4002358291,
+    "approx_tokens_1_3x_words": 767186898
+  },
+  "provider_counts": {
+    "mistral": 362596,
+    "openrouter": 8406
+  },
+  "model_counts": {
+    "mistral-small-latest": 288189,
+    "mistral-medium-latest": 74407,
+    "nvidia/nemotron-3-super-120b-a12b:free": 8406
+  },
+  "source_counts": {
+    "v2_synthetic_mistral_small_latest": 288189,
+    "v2_synthetic_mistral_medium_latest": 74407,
+    "v2_synthetic_openrouter_nvidia_nemotron_3_super_120b_a12b_free": 8406
+  },
+  "file_counts": {
+    "corpus11 (2).jsonl": 25985,
+    "cropus10 (1).jsonl": 25985,
+    "corpus11 (1).jsonl": 24984,
+    "corpus13.jsonl": 24982,
+    "cropus10 (2).jsonl": 21775,
+    "corpus8.jsonl": 19194,
+    "corpus20 (2).jsonl": 15983,
+    "corpus18 (1).jsonl": 15930,
+    "corpus18 (2).jsonl": 15891,
+    "corpus15 (1).jsonl": 14992,
+    "corpus15 (2).jsonl": 14992,
+    "corpus3.jsonl": 14933,
+    "corpus19.jsonl": 11769,
+    "corpus9.jsonl": 11721,
+    "corpus6.jsonl": 10568,
+    "corpus12.jsonl": 10453,
+    "corpus5.jsonl": 10019,
+    "corpus4.jsonl": 8266,
+    "corpus7 (2).jsonl": 7990,
+    "corpus16.jsonl": 7498,
+    "corpus17 (1).jsonl": 6874,
+    "corpus17 (2).jsonl": 6729,
+    "corpus (2).jsonl": 6231,
+    "corpus1.jsonl": 6202,
+    "corpus7 (1).jsonl": 6015,
+    "vl1.jsonl": 5997,
+    "corpus20 (1).jsonl": 5621,
+    "synthetic_corpus_mistral_single.jsonl": 5017,
+    "corpus21.jsonl": 1434,
+    "synthetic_corpus_openrouter_single.jsonl": 1348,
+    "corpus11.jsonl": 1225,
+    "corpus14.jsonl": 1203,
+    "opencorpus1.jsonl": 1130,
+    "synthetic_corpus_openrouter_single (1).jsonl": 1038,
+    "corpus (1).jsonl": 1028
+  },
+  "shards": [
+    {
+      "path": "corpus-ptbr-v2/data/v2-synthetic-00000.parquet",
+      "rows": 100000,
+      "bytes": 421327562
+    },
+    {
+      "path": "corpus-ptbr-v2/data/v2-synthetic-00001.parquet",
+      "rows": 100000,
+      "bytes": 424618319
+    },
+    {
+      "path": "corpus-ptbr-v2/data/v2-synthetic-00002.parquet",
+      "rows": 100000,
+      "bytes": 484016248
+    },
+    {
+      "path": "corpus-ptbr-v2/data/v2-synthetic-00003.parquet",
+      "rows": 71002,
+      "bytes": 315068755
+    }
+  ]
+}

scripts/prepare_v2_synthetic_parquet.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+from collections import Counter
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+DEFAULT_INPUT_DIR = Path("CORPUS")
+DEFAULT_OUTPUT_DIR = Path("corpus-ptbr-v2/data")
+DEFAULT_MANIFEST = Path("corpus-ptbr-v2/manifests/v2_synthetic_addition_manifest.json")
+
+SCHEMA = pa.schema(
+    [
+        ("text", pa.string()),
+        ("source", pa.string()),
+        ("subset", pa.string()),
+        ("word_count", pa.int32()),
+        ("char_count", pa.int32()),
+        ("language", pa.string()),
+    ]
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Convert local synthetic JSONL corpus files into v1-compatible Parquet shards for corpus-ptbr-v2."
+    )
+    parser.add_argument("--input-dir", type=Path, default=DEFAULT_INPUT_DIR)
+    parser.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT_DIR)
+    parser.add_argument("--manifest", type=Path, default=DEFAULT_MANIFEST)
+    parser.add_argument("--rows-per-shard", type=int, default=100_000)
+    parser.add_argument("--min-words", type=int, default=1)
+    parser.add_argument("--max-words", type=int, default=0, help="0 means no upper limit.")
+    parser.add_argument("--limit", type=int, default=0, help="0 means no limit.")
+    parser.add_argument("--compression", default="zstd")
+    parser.add_argument("--basename", default="v2-synthetic")
+    parser.add_argument("--overwrite", action="store_true")
+    parser.add_argument("--no-dedupe", action="store_true")
+    return parser.parse_args()
+
+
+def normalize_slug(value: str) -> str:
+    value = value.strip().lower()
+    value = value.replace("/", "_").replace(":", "_")
+    value = re.sub(r"[^a-z0-9]+", "_", value)
+    value = re.sub(r"_+", "_", value).strip("_")
+    return value or "unknown"
+
+
+def source_from_metadata(provider: Any, model: Any) -> str:
+    provider_slug = normalize_slug(str(provider or "unknown"))
+    model_slug = normalize_slug(str(model or "unknown"))
+    if provider_slug == "mistral" and model_slug.startswith("mistral_"):
+        return f"v2_synthetic_{model_slug}"
+    return f"v2_synthetic_{provider_slug}_{model_slug}"
+
+
+def safe_int(value: Any, fallback: int) -> int:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return fallback
+
+
+def iter_jsonl_files(input_dir: Path) -> list[Path]:
+    return sorted(path for path in input_dir.rglob("*.jsonl") if path.is_file())
+
+
+def write_shard(
+    rows: list[dict[str, Any]],
+    output_dir: Path,
+    basename: str,
+    shard_idx: int,
+    compression: str,
+) -> dict[str, Any]:
+    table = pa.Table.from_pylist(rows, schema=SCHEMA)
+    output_path = output_dir / f"{basename}-{shard_idx:05d}.parquet"
+    pq.write_table(
+        table,
+        output_path,
+        compression=compression,
+        row_group_size=min(len(rows), 10_000),
+    )
+    return {
+        "path": output_path.as_posix(),
+        "rows": len(rows),
+        "bytes": output_path.stat().st_size,
+    }
+
+
+def main() -> None:
+    args = parse_args()
+
+    if args.rows_per_shard <= 0:
+        raise ValueError("--rows-per-shard must be positive.")
+    if not args.input_dir.exists():
+        raise FileNotFoundError(f"Input directory not found: {args.input_dir}")
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    args.manifest.parent.mkdir(parents=True, exist_ok=True)
+
+    existing = sorted(args.output_dir.glob(f"{args.basename}-*.parquet"))
+    if existing and not args.overwrite:
+        raise FileExistsError(
+            f"Found existing shards in {args.output_dir}. Use --overwrite to replace them."
+        )
+    if existing and args.overwrite:
+        for path in existing:
+            path.unlink()
+
+    files = iter_jsonl_files(args.input_dir)
+    rows: list[dict[str, Any]] = []
+    seen_text_hashes: set[str] = set()
+    shard_idx = 0
+    shard_infos: list[dict[str, Any]] = []
+
+    provider_counts: Counter[str] = Counter()
+    model_counts: Counter[str] = Counter()
+    source_counts: Counter[str] = Counter()
+    file_counts: Counter[str] = Counter()
+
+    total_records_seen = 0
+    total_records_written = 0
+    total_words = 0
+    total_chars = 0
+    skipped_empty = 0
+    skipped_parse_error = 0
+    skipped_duplicate = 0
+    skipped_too_short = 0
+    skipped_too_long = 0
+
+    for file_path in files:
+        with file_path.open("r", encoding="utf-8") as handle:
+            for line_number, line in enumerate(handle, start=1):
+                if args.limit and total_records_written >= args.limit:
+                    break
+                if not line.strip():
+                    continue
+
+                total_records_seen += 1
+                try:
+                    obj = json.loads(line)
+                except json.JSONDecodeError:
+                    skipped_parse_error += 1
+                    continue
+
+                text = str(obj.get("text") or "").strip()
+                if not text:
+                    skipped_empty += 1
+                    continue
+
+                text_hash = hashlib.sha256(text.encode("utf-8")).hexdigest()
+                if not args.no_dedupe and text_hash in seen_text_hashes:
+                    skipped_duplicate += 1
+                    continue
+                seen_text_hashes.add(text_hash)
+
+                word_count = safe_int(obj.get("word_count"), len(text.split()))
+                char_count = safe_int(obj.get("char_count"), len(text))
+                if word_count < args.min_words:
+                    skipped_too_short += 1
+                    continue
+                if args.max_words and word_count > args.max_words:
+                    skipped_too_long += 1
+                    continue
+
+                provider = str(obj.get("provider") or "unknown")
+                model = str(obj.get("model") or "unknown")
+                source = source_from_metadata(provider, model)
+
+                rows.append(
+                    {
+                        "text": text,
+                        "source": source,
+                        "subset": "synthetic",
+                        "word_count": word_count,
+                        "char_count": char_count,
+                        "language": "pt-br",
+                    }
+                )
+
+                provider_counts[provider] += 1
+                model_counts[model] += 1
+                source_counts[source] += 1
+                file_counts[file_path.name] += 1
+                total_records_written += 1
+                total_words += word_count
+                total_chars += char_count
+
+                if len(rows) >= args.rows_per_shard:
+                    shard_infos.append(
+                        write_shard(rows, args.output_dir, args.basename, shard_idx, args.compression)
+                    )
+                    shard_idx += 1
+                    rows = []
+
+            if args.limit and total_records_written >= args.limit:
+                break
+
+    if rows:
+        shard_infos.append(write_shard(rows, args.output_dir, args.basename, shard_idx, args.compression))
+
+    manifest = {
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "input_dir": args.input_dir.as_posix(),
+        "output_dir": args.output_dir.as_posix(),
+        "schema": [
+            {"name": field.name, "type": str(field.type)}
+            for field in SCHEMA
+        ],
+        "settings": {
+            "rows_per_shard": args.rows_per_shard,
+            "min_words": args.min_words,
+            "max_words": args.max_words,
+            "limit": args.limit,
+            "compression": args.compression,
+            "dedupe_exact_text": not args.no_dedupe,
+        },
+        "counts": {
+            "jsonl_files": len(files),
+            "records_seen": total_records_seen,
+            "records_written": total_records_written,
+            "records_skipped_empty": skipped_empty,
+            "records_skipped_parse_error": skipped_parse_error,
+            "records_skipped_duplicate_text": skipped_duplicate,
+            "records_skipped_too_short": skipped_too_short,
+            "records_skipped_too_long": skipped_too_long,
+            "total_words": total_words,
+            "total_chars": total_chars,
+            "approx_tokens_1_3x_words": int(total_words * 1.3),
+        },
+        "provider_counts": dict(provider_counts.most_common()),
+        "model_counts": dict(model_counts.most_common()),
+        "source_counts": dict(source_counts.most_common()),
+        "file_counts": dict(file_counts.most_common()),
+        "shards": shard_infos,
+    }
+
+    args.manifest.write_text(json.dumps(manifest, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    print("V2 synthetic Parquet preparation complete.")
+    print(f"Records written : {total_records_written}")
+    print(f"Shards written  : {len(shard_infos)}")
+    print(f"Total words     : {total_words}")
+    print(f"Approx tokens   : {int(total_words * 1.3)}")
+    print(f"Manifest        : {args.manifest}")
+
+
+if __name__ == "__main__":
+    main()

scripts/upload_v2_after_duplicate.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import argparse
+import os
+from pathlib import Path
+
+from huggingface_hub import HfApi
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Upload the local corpus-ptbr-v2 package to a Hugging Face dataset repo. "
+            "Recommended flow: duplicate Madras1/corpus-ptbr-v1 to Madras1/corpus-ptbr-v2 first, "
+            "then run this script to replace README.md and add the v2 synthetic shards."
+        )
+    )
+    parser.add_argument("--repo-id", default="Madras1/corpus-ptbr-v2")
+    parser.add_argument("--folder", type=Path, default=Path("corpus-ptbr-v2"))
+    parser.add_argument("--create-repo", action="store_true")
+    parser.add_argument("--private", action="store_true")
+    parser.add_argument("--revision", default="main")
+    parser.add_argument("--commit-message", default="Add Corpus PT-BR v2 synthetic extension")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    if not args.folder.exists():
+        raise FileNotFoundError(f"Folder not found: {args.folder}")
+    if not os.getenv("HF_TOKEN"):
+        print("Warning: HF_TOKEN is not set. The Hugging Face Hub client may use cached login credentials.")
+
+    api = HfApi()
+    if args.create_repo:
+        api.create_repo(
+            repo_id=args.repo_id,
+            repo_type="dataset",
+            private=args.private,
+            exist_ok=True,
+        )
+
+    api.upload_folder(
+        repo_id=args.repo_id,
+        repo_type="dataset",
+        folder_path=str(args.folder),
+        revision=args.revision,
+        commit_message=args.commit_message,
+        ignore_patterns=[
+            "scripts/__pycache__/*",
+            "test-output/*",
+            "*.tmp",
+        ],
+    )
+    print(f"Uploaded {args.folder} to dataset repo {args.repo_id}.")
+
+
+if __name__ == "__main__":
+    main()