Upload merge-upload.py with huggingface_hub

merge-upload.py

@@ -0,0 +1,170 @@
+import gc
+import glob
+import os
+import shutil
+import time
+
+import polars as pl
+from huggingface_hub import HfApi
+
+run_conversion = (
+    input(
+        "\nwould you like to run the CSV to parquet conversion ('n' to skip to upload)? (y/n): "
+    )
+    .strip()
+    .lower()
+)
+
+output_dir = ""
+
+if run_conversion == "y":
+    csv_dir = input("enter directory containing CSV files: ").strip()
+
+    while not csv_dir:
+        print("error: directory cannot be empty.")
+        csv_dir = input("enter directory containing CSV files: ").strip()
+
+    os.chdir(csv_dir)
+    output_dir = "parquet_dataset"
+
+    csv_files = sorted(glob.glob("*.csv"))
+
+    if not csv_files:
+        print("no CSV files found in current directory.")
+        exit(1)
+
+    print(f"found {len(csv_files)} CSV files.")
+
+    if os.path.exists(output_dir):
+        print(f"cleaning up old '{output_dir}' directory...")
+        shutil.rmtree(output_dir)
+
+    os.makedirs(output_dir)
+
+    chunk_size = 3
+    batches = [
+        csv_files[i : i + chunk_size] for i in range(0, len(csv_files), chunk_size)
+    ]
+
+    print(f"\nprocessing {len(csv_files)} files into {len(batches)} parquet files...")
+
+    total_rows = 0
+    total_cols = None
+
+    start_time = time.time()
+
+    for batch_idx, batch_files in enumerate(batches):
+        print(
+            f"\n--- processing batch {batch_idx + 1}/{len(batches)} ({len(batch_files)} files) ---"
+        )
+
+        batch_dfs = []
+
+        for f in batch_files:
+            df = pl.read_csv(
+                f,
+                schema_overrides={
+                    "delta_start": pl.Utf8,
+                    "handshake_duration": pl.Utf8,
+                    "payload_bytes_skewness": pl.Utf8,
+                    "payload_bytes_cov": pl.Utf8,
+                    "fwd_payload_bytes_skewness": pl.Utf8,
+                    "fwd_payload_bytes_cov": pl.Utf8,
+                    "bwd_payload_bytes_skewness": pl.Utf8,
+                    "bwd_payload_bytes_cov": pl.Utf8,
+                    "fwd_skewness_header_bytes": pl.Utf8,
+                    "bwd_skewness_header_bytes": pl.Utf8,
+                    "packets_IAT_skewness": pl.Utf8,
+                    "fwd_packets_IAT_skewness": pl.Utf8,
+                    "bwd_packets_IAT_skewness": pl.Utf8,
+                    "skewness_packets_delta_time": pl.Utf8,
+                    "skewness_packets_delta_len": pl.Utf8,
+                    "skewness_header_bytes_delta_len": pl.Utf8,
+                    "skewness_payload_bytes_delta_len": pl.Utf8,
+                    "cov_payload_bytes_delta_len": pl.Utf8,
+                },
+            )
+
+            row_count = len(df)
+            col_count = len(df.columns)
+            total_rows += row_count
+
+            print(f"  - {f}: {row_count:,} rows, {col_count} columns")
+
+            if total_cols is None:
+                total_cols = col_count
+            elif col_count != total_cols:
+                print(
+                    f"✗ ERROR: column mismatch in {f}! expected {total_cols}, got {col_count}"
+                )
+                exit(1)
+
+            batch_dfs.append(df)
+
+        print(f"  merging batch {batch_idx + 1}...")
+        combined_batch = pl.concat(batch_dfs)
+
+        output_filename = os.path.join(output_dir, f"chunk_{batch_idx + 1:02d}.parquet")
+        combined_batch.write_parquet(output_filename)
+        print(f"  ✓ saved to {output_filename}")
+
+        del batch_dfs
+        del combined_batch
+        del df
+        gc.collect()
+
+    end_time = time.time()
+    elapsed_minutes = (end_time - start_time) / 60
+
+    full_path = os.path.abspath(output_dir)
+    print("\n" + "=" * 40)
+    print(f"conversion completed in {elapsed_minutes:.2f} minutes")
+    print(f"total input rows processed: {total_rows:,}")
+    print(f"parquet files saved in: {full_path}")
+    print("=" * 40 + "\n")
+
+else:
+    print("\nskipping conversion step...")
+    output_dir = input("enter the directory path you want to upload: ").strip()
+    while output_dir and not os.path.isdir(output_dir):
+        print(f"✗ error: directory '{output_dir}' does not exist.")
+        output_dir = input(
+            "enter a valid directory path (or press Enter to cancel): "
+        ).strip()
+
+    if output_dir:
+        output_dir = os.path.abspath(output_dir)
+
+if output_dir:
+    repo_id = input(
+        f"\nenter your huggingface repo id to upload '{output_dir}' (or press Enter to skip upload): "
+    ).strip()
+
+    if repo_id:
+        if "/" not in repo_id:
+            print(
+                "✗ error: invalid repo id. it must contain a forward slash '/' separating your username and repo name"
+            )
+        else:
+            try:
+                print(f"\ninitializing upload to {repo_id}...")
+                api = HfApi()
+
+                api.upload_folder(
+                    folder_path=output_dir,
+                    repo_id=repo_id,
+                    repo_type="dataset",
+                )
+                print("\n✓ upload successful. dataset is now on huggingface.")
+            except Exception as e:
+                print(
+                    "\n✗ upload failed. make sure you are logged in via 'hf auth login'."
+                )
+                print(f"error details: {e}")
+    else:
+        print(
+            f"\nupload skipped. you can manually upload the folder later with:\n"
+            f"`hf upload --type dataset REPO_ID {output_dir} [path_in_repo]`"
+        )
+else:
+    print("upload skipped. you can manually upload the folder later.")