Upload src/upload_culturax.py with huggingface_hub

src/upload_culturax.py

@@ -0,0 +1,228 @@
+import os
+import json
+import argparse
+from datetime import datetime
+from datasets import Dataset
+from huggingface_hub import HfApi, upload_file
+import shutil
+import math
+
+def clean_jsonl_data(file_path):
+    """Clean and validate JSONL file data."""
+    cleaned_data = []
+    with open(file_path, "r", encoding="utf-8") as f:
+        for line_number, line in enumerate(f, start=1):
+            try:
+                data = json.loads(line)
+
+                # Validate 'timestamp' field
+                if "timestamp" in data:
+                    if not data["timestamp"] or not isinstance(data["timestamp"], str):
+                        data["timestamp"] = None
+                    else:
+                        try:
+                            datetime_obj = datetime.fromisoformat(
+                                data["timestamp"].replace("Z", "+00:00")
+                            )
+                            data["timestamp"] = datetime_obj.isoformat()
+                        except ValueError:
+                            data["timestamp"] = None
+
+                # Ensure 'text' is a string
+                if "text" in data and not isinstance(data["text"], str):
+                    data["text"] = str(data["text"]) if data["text"] is not None else None
+
+                # Validate 'url' and 'source'
+                if "url" in data and not isinstance(data["url"], str):
+                    data["url"] = str(data["url"]) if data["url"] is not None else None
+
+                if "source" in data and not isinstance(data["source"], str):
+                    data["source"] = str(data["source"]) if data["source"] is not None else None
+
+                cleaned_data.append(data)
+
+            except json.JSONDecodeError as e:
+                print(f"JSON decode error at line {line_number}: {e}")
+            except Exception as e:
+                print(f"Error processing line {line_number}: {e}")
+
+    return cleaned_data
+
+def estimate_num_shards(file_path, target_shard_size_gb=1):
+    """Estimate the number of shards needed based on file size."""
+    file_size_gb = os.path.getsize(file_path) / (1024 ** 3)  # Bytes to GB
+    num_shards = max(1, math.ceil(file_size_gb / target_shard_size_gb))
+    return num_shards
+
+def split_jsonl_file(input_file, output_prefix, max_size_gb=45):
+    """Split large JSONL files into smaller shards."""
+    file_size_gb = os.path.getsize(input_file) / (1024 ** 3)  # Convert bytes to GB
+    if file_size_gb <= max_size_gb:
+        return [input_file]  # No need to split if below limit
+
+    # Calculate lines per shard
+    with open(input_file, "r", encoding="utf-8") as f:
+        lines = f.readlines()
+    num_lines = len(lines)
+
+    num_shards = math.ceil(file_size_gb / max_size_gb)
+    lines_per_shard = math.ceil(num_lines / num_shards)
+
+    shard_files = []
+    for i in range(num_shards):
+        shard_file = f"{output_prefix}_part{i+1}.jsonl"
+        with open(shard_file, "w", encoding="utf-8") as f:
+            f.writelines(lines[i * lines_per_shard:(i + 1) * lines_per_shard])
+        shard_files.append(shard_file)
+
+    return shard_files
+
+def upload_large_file(file_path, repo_id, path_in_repo, repo_type="dataset"):
+    """Upload large files with multi-part upload handling."""
+    file_size_mb = os.path.getsize(file_path) / (1024 ** 2)  # Convert bytes to MB
+    # Use multi-part upload for files > 5MB
+    if file_size_mb > 5:
+        upload_file(
+            path_or_fileobj=file_path,
+            path_in_repo=path_in_repo,
+            repo_id=repo_id,
+            repo_type=repo_type,
+            use_auth_token=True,
+        )
+        print(f"Uploaded '{path_in_repo}' with multi-part upload.")
+    else:
+        # Direct upload for smaller files
+        with open(file_path, 'rb') as f:
+            api = HfApi()
+            api.upload_file(
+                path_or_fileobj=f,
+                path_in_repo=path_in_repo,
+                repo_id=repo_id,
+                repo_type=repo_type,
+                use_auth_token=True,
+            )
+        print(f"Uploaded '{path_in_repo}' with direct upload.")
+
+def create_and_upload_dataset(language):
+    # Define constants
+    org_name = "ScandLM"
+    dataset_name = f"{language}_culturax"
+    repo_id = f"{org_name}/{dataset_name}"
+    jsonl_file = f"{language}_culturax.jsonl"
+    temp_folder = f"temp_{language}"
+    jsonl_folder = os.path.join(temp_folder, "jsonl")
+    data_folder = os.path.join(temp_folder, "data")
+    src_folder = os.path.join(temp_folder, "src")
+
+    # Language codes
+    language_codes = {"danish": "da", "swedish": "sv", "norwegian": "no", "nynorsk": "nn"}
+    language_code = language_codes.get(language, "unknown")
+
+    # YAML front matter
+    yaml_tags = (
+        f"---\n"
+        f"language: [{language_code}]\n"
+        f"---\n\n"
+        f"# {language.capitalize()} Culturax Dataset\n\n"
+        f"This dataset is simply a reformatting of uonlp/CulturaX. "
+        f"Some minor formatting errors have been corrected.\n\n"
+        f"## Usage\n\n"
+        f"```python\n"
+        f"from datasets import load_dataset\n\n"
+        f"dataset = load_dataset(\"ScandLM/{language}_culturax\")\n"
+        f"```\n"
+    )
+
+    # Verify JSONL file
+    if not os.path.exists(jsonl_file):
+        raise FileNotFoundError(f"The file '{jsonl_file}' was not found.")
+
+    # Clean data and create a temporary JSONL file
+    cleaned_data = clean_jsonl_data(jsonl_file)
+    os.makedirs(jsonl_folder, exist_ok=True)
+    cleaned_jsonl_file = os.path.join(jsonl_folder, f"cleaned_{jsonl_file}")
+    with open(cleaned_jsonl_file, "w", encoding="utf-8") as f:
+        for entry in cleaned_data:
+            json.dump(entry, f)
+            f.write("\n")
+
+    # Split JSONL if too large
+    jsonl_shards = split_jsonl_file(cleaned_jsonl_file, os.path.join(jsonl_folder, language), max_size_gb=45)
+
+    # Load data into Dataset
+    dataset = Dataset.from_json(cleaned_jsonl_file)
+
+    # Estimate and create Parquet shards
+    num_shards = estimate_num_shards(cleaned_jsonl_file, target_shard_size_gb=1)
+    print(f"Number of Parquet shards: {num_shards}")
+
+    os.makedirs(data_folder, exist_ok=True)
+    parquet_files = []
+    for shard_id in range(num_shards):
+        shard = dataset.shard(num_shards=num_shards, index=shard_id)
+        parquet_file = os.path.join(data_folder, f"train-{shard_id:05d}-of-{num_shards:05d}.parquet")
+        shard.to_parquet(parquet_file)
+        parquet_files.append(parquet_file)
+        print(f"Parquet file created: {parquet_file}")
+
+    # Authenticate with Hugging Face
+    api = HfApi()
+
+    # Create dataset repo
+    api.create_repo(repo_id=repo_id, repo_type="dataset", private=False, exist_ok=True)
+    print(f"Dataset repository '{repo_id}' created successfully.")
+
+    # Upload Parquet files
+    for parquet_file in parquet_files:
+        upload_large_file(
+            file_path=parquet_file,
+            repo_id=repo_id,
+            path_in_repo=f"data/{os.path.basename(parquet_file)}",
+        )
+
+    # Upload JSONL shards
+    for shard_file in jsonl_shards:
+        upload_large_file(
+            file_path=shard_file,
+            repo_id=repo_id,
+            path_in_repo=f"jsonl/{os.path.basename(shard_file)}",
+        )
+
+    # Upload README
+    readme_path = os.path.join(temp_folder, "README.md")
+    with open(readme_path, "w", encoding="utf-8") as f:
+        f.write(yaml_tags)
+
+    upload_file(
+        path_or_fileobj=readme_path,
+        path_in_repo="README.md",
+        repo_id=repo_id,
+        repo_type="dataset",
+        use_auth_token=True
+    )
+    print("README.md uploaded successfully.")
+
+    # Upload scripts
+    os.makedirs(src_folder, exist_ok=True)
+    for script in ["download_culturax.py", "upload_culturax.py"]:
+        if os.path.exists(script):
+            upload_large_file(
+                file_path=script,
+                repo_id=repo_id,
+                path_in_repo=f"src/{script}",
+            )
+
+    # Clean up temporary files
+    if os.path.exists(readme_path):
+        os.remove(readme_path)
+
+    # Remove directories
+    shutil.rmtree(temp_folder, ignore_errors=True)
+
+    print("Dataset setup complete!")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Upload a cultural dataset to Hugging Face.")
+    parser.add_argument("language", type=str, help="The language for the dataset (e.g., danish, swedish, norwegian, nynorsk).")
+    args = parser.parse_args()
+    create_and_upload_dataset(args.language)