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)