Upload src/upload_culturax.py with huggingface_hub

src/upload_culturax.py

@@ -5,16 +5,17 @@ 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 the JSONL file data and ensure proper formatting."""
+    """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)
 
-                # Check and clean 'timestamp' field
+                # Validate 'timestamp' field
                 if "timestamp" in data:
                     if not data["timestamp"] or not isinstance(data["timestamp"], str):
                         data["timestamp"] = None
@@ -27,11 +28,11 @@ def clean_jsonl_data(file_path):
                         except ValueError:
                             data["timestamp"] = None
 
-                # Ensure 'text' field is a string
+                # 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
 
-                # Check for other fields, e.g., 'url', 'source'
+                # 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
 
@@ -41,39 +42,83 @@ def clean_jsonl_data(file_path):
                 cleaned_data.append(data)
 
             except json.JSONDecodeError as e:
-                print(f"JSON decoding error at line {line_number}: {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 based on the JSONL file size."""
-    file_size_gb = os.path.getsize(file_path) / (1024 ** 3)  # Convert bytes to GB
-    num_shards = max(1, int(file_size_gb / target_shard_size_gb) + 1)  # Ensure at least one shard
+    """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"
-    parquet_file_prefix = f"{language}_culturax"
-    jsonl_folder, data_folder, src_folder = "jsonl", "data", "src"
-
-    # Map the language argument to two-letter language code
-    language_codes = {
-        "danish": "da",
-        "swedish": "sv",
-        "norwegian": "no",
-        "nynorsk": "nn",
-    }
-    
-    # Get the correct two-letter language code
+    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")
 
-    # Simplified YAML tags for dataset card
+    # YAML front matter
     yaml_tags = (
         f"---\n"
         f"language: [{language_code}]\n"
@@ -88,14 +133,12 @@ def create_and_upload_dataset(language):
         f"```\n"
     )
 
-    # Check if JSONL file exists
+    # Verify JSONL file
     if not os.path.exists(jsonl_file):
         raise FileNotFoundError(f"The file '{jsonl_file}' was not found.")
 
-    # Clean data before creating the dataset
+    # Clean data and create a temporary JSONL file
     cleaned_data = clean_jsonl_data(jsonl_file)
-
-    # Write cleaned data to a temporary 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:
@@ -103,16 +146,17 @@ def create_and_upload_dataset(language):
             json.dump(entry, f)
             f.write("\n")
 
-    # Load the cleaned JSONL file into a Hugging Face dataset
+    # 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 Parquet file size and determine number of shards
+    # Estimate and create Parquet shards
     num_shards = estimate_num_shards(cleaned_jsonl_file, target_shard_size_gb=1)
-    print(f"Number of shards: {num_shards}")
+    print(f"Number of Parquet shards: {num_shards}")
 
-    # Create Parquet file
     os.makedirs(data_folder, exist_ok=True)
-    # Define parquet filename with a typical training file convention
     parquet_files = []
     for shard_id in range(num_shards):
         shard = dataset.shard(num_shards=num_shards, index=shard_id)
@@ -121,74 +165,64 @@ def create_and_upload_dataset(language):
         parquet_files.append(parquet_file)
         print(f"Parquet file created: {parquet_file}")
 
-    # Authenticate using the Hugging Face API token
+    # Authenticate with Hugging Face
     api = HfApi()
 
-    # Create a new dataset in the ScandLM organization
+    # 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_file(
-            path_or_fileobj=parquet_file,
-            path_in_repo=f"{data_folder}/{os.path.basename(parquet_file)}",
+        upload_large_file(
+            file_path=parquet_file,
             repo_id=repo_id,
-            repo_type="dataset",
+            path_in_repo=f"data/{os.path.basename(parquet_file)}",
         )
-        print(f"Parquet file '{parquet_file}' uploaded successfully.")
 
-    # Upload JSONL file to the jsonl folder
-    upload_file(
-        path_or_fileobj=cleaned_jsonl_file,
-        path_in_repo=f"{jsonl_folder}/{os.path.basename(cleaned_jsonl_file)}",
-        repo_id=repo_id,
-        repo_type="dataset",
-    )
-    print(f"JSONL file '{cleaned_jsonl_file}' uploaded successfully.")
+    # 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)}",
+        )
 
-    # Create README.md file locally with YAML tags
-    readme_path = "README.md"
+    # 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 README.md to the repository
     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 Python scripts
+    # Upload scripts
     os.makedirs(src_folder, exist_ok=True)
     for script in ["download_culturax.py", "upload_culturax.py"]:
         if os.path.exists(script):
-            upload_file(
-                path_or_fileobj=script,
-                path_in_repo=f"{src_folder}/{script}",
+            upload_large_file(
+                file_path=script,
                 repo_id=repo_id,
-                repo_type="dataset",
+                path_in_repo=f"src/{script}",
             )
-            print(f"Script '{script}' uploaded successfully.")
 
     # Clean up temporary files
     if os.path.exists(readme_path):
         os.remove(readme_path)
-    if os.path.exists(cleaned_jsonl_file):
-        os.remove(cleaned_jsonl_file)
 
-    # Remove created directories and their contents
-    shutil.rmtree(jsonl_folder, ignore_errors=True)
-    shutil.rmtree(data_folder, ignore_errors=True)
-    shutil.rmtree(src_folder, ignore_errors=True)
+    # 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)