test

Pipfile

@@ -0,0 +1,11 @@
+[[source]]
+url = "https://pypi.org/simple"
+verify_ssl = true
+name = "pypi"
+
+[packages]
+
+[dev-packages]
+
+[requires]
+python_version = "3.9"

check_json.py

@@ -0,0 +1,18 @@
+import json
+
+with open("dataset_infos.json") as f:
+    root = json.load(f)
+
+# Should be a dict with exactly one key
+assert isinstance(root, dict), "Root must be a dict"
+assert len(root) == 1, "Root must contain exactly one config"
+config_name, info = next(iter(root.items()))
+
+# Info must itself be a dict
+assert isinstance(info, dict), f"Value for config '{config_name}' is not a dict"
+
+# It must have all required keys
+for key in ("features", "splits", "dataset_size"):
+    assert key in info, f"Missing '{key}' in config '{config_name}'"
+
+print("✅ dataset_infos.json structure looks good under config:", config_name)

generate_info.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""
+generate_info.py
+
+Scan all .parquet files in a given directory for schema & metadata,
+and write a valid Hugging Face `dataset_infos.json` with a top-level config name.
+"""
+
+import glob
+import os
+import json
+import argparse
+import sys
+
+# Try using pyarrow for fast schema inspection & list detection
+USE_PYARROW = False
+try:
+    import pyarrow.parquet as pq
+    import pyarrow as pa
+    USE_PYARROW = True
+except ImportError:
+    import pandas as pd
+
+# Primitive type mapping (map Arrow string repr → HF dtype)
+PRIMITIVE_MAP = {
+    "int64":   "int64",
+    "int32":   "int32",
+    "float64": "float32",  # HF uses float32
+    "double":  "float32",
+    "float32": "float32",
+    "string":  "string",
+    "binary":  "binary",
+}
+
+def inspect_parquet(path):
+    """
+    Return (features_dict, num_rows, num_bytes) for a single Parquet file.
+    Detects primitive and list types via pyarrow if available.
+    """
+    if USE_PYARROW:
+        pf = pq.ParquetFile(path)
+        schema = pf.schema_arrow
+        feats = {}
+        for field in schema:
+            name = field.name
+            dtype = field.type
+            dtype_str = str(dtype)
+            if pa.types.is_list(dtype):
+                # List-of-primitive case
+                elem_str = str(dtype.value_type)
+                mapped = PRIMITIVE_MAP.get(elem_str, elem_str)
+                feats[name] = {
+                    "_type": "Sequence",
+                    "feature": {"dtype": mapped},
+                    "length": -1
+                }
+            else:
+                # Primitive case
+                mapped = PRIMITIVE_MAP.get(dtype_str, dtype_str)
+                feats[name] = {"dtype": mapped}
+        num_rows = pf.metadata.num_rows
+    else:
+        # Fallback: load full table with pandas (no list detection)
+        df = pd.read_parquet(path)
+        feats = {
+            col: {"dtype": PRIMITIVE_MAP.get(str(dt), str(dt))}
+            for col, dt in df.dtypes.items()
+        }
+        num_rows = len(df)
+
+    size_bytes = os.path.getsize(path)
+    return feats, num_rows, size_bytes
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate HF-style dataset_infos.json from Parquet files"
+    )
+    parser.add_argument(
+        "-d", "--parquet-dir",
+        default=".",
+        help="Directory containing .parquet files"
+    )
+    parser.add_argument(
+        "-p", "--pattern",
+        default="*.parquet",
+        help="Glob pattern to match Parquet files"
+    )
+    parser.add_argument(
+        "-o", "--output",
+        default="dataset_infos.json",
+        help="Output JSON filename"
+    )
+    args = parser.parse_args()
+
+    pattern = os.path.join(args.parquet_dir, args.pattern)
+    files = sorted(glob.glob(pattern))
+    if not files:
+        sys.stderr.write(f"No files found matching: {pattern}\n")
+        sys.exit(1)
+
+    # Extract schema & row count from first file
+    features, row_count, _ = inspect_parquet(files[0])
+    if not features:
+        sys.stderr.write("No features detected—check your schema!\n")
+        sys.exit(1)
+
+    # Sum byte sizes across all files
+    total_bytes = sum(inspect_parquet(f)[2] for f in files)
+
+    # Build the dataset info under the "default" config
+    dataset_infos = {
+        "default": {
+            "features": features,
+            "splits": {
+                "train": {
+                    "num_examples": row_count,
+                    "num_bytes": total_bytes
+                }
+            },
+            "dataset_size": total_bytes
+        }
+    }
+
+    # Write to disk
+    with open(args.output, "w") as fp:
+        json.dump(dataset_infos, fp, indent=2)
+
+    print(f"Wrote {args.output} ({len(files)} files, {total_bytes} bytes):")
+    print(json.dumps(dataset_infos, indent=2))
+
+if __name__ == "__main__":
+    main()

generate_manually.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+import json
+import os
+from datasets import load_dataset
+
+# --- CONFIGURATION: list your local Parquet files here ---
+data_files = {
+    "train": [
+        "embeddings_pcs_shape.parquet",
+        "embeddings_pcs_texture.parquet",
+        "embeddings_pcs_width.parquet",
+    ]
+}
+
+# 1. Load the Parquets as a single-train-split Dataset
+ds = load_dataset(
+    "parquet",
+    data_files=data_files,
+    split="train"
+)
+
+# 2. Extract the metadata from ds.info
+info = ds.info
+
+# Features: convert to plain dict
+features_dict = info.features.to_dict()
+
+# Splits: collect num_examples & num_bytes
+splits_dict = {
+    split_name: {
+        "num_examples": split_info.num_examples,
+        "num_bytes":   split_info.num_bytes,
+    }
+    for split_name, split_info in info.splits.items()
+}
+
+# Dataset size
+dataset_size = info.dataset_size
+
+# 3. Wrap under "default" config
+final = {
+    "default": {
+        "features":     features_dict,
+        "splits":       splits_dict,
+        "dataset_size": dataset_size,
+    }
+}
+
+# 4. Write out the JSON
+with open("dataset_infos.json", "w") as f:
+    json.dump(final, f, indent=2)
+
+print("✅ Wrote dataset_infos.json:")
+print(json.dumps(final, indent=2))

hf-test

@@ -0,0 +1 @@
+Subproject commit 34e7b813658391d045af7f1a9b17e13343444a18

split_parquet.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""
+split_parquet.py
+
+Creates a smaller sample of existing Parquet files by taking the first N rows
+from each and writing them to new files with a `_sample` suffix.
+"""
+
+import pandas as pd
+import glob
+import os
+import argparse
+
+def split_parquet(input_dir, pattern, output_dir, nrows):
+    os.makedirs(output_dir, exist_ok=True)
+    files = glob.glob(os.path.join(input_dir, pattern))
+    if not files:
+        print(f"No files found matching {pattern} in {input_dir}")
+        return
+
+    for path in files:
+        df = pd.read_parquet(path, engine="pyarrow")
+        sample = df.head(nrows)
+        base = os.path.basename(path)
+        out_name = base.replace(".parquet", f"_sample{nrows}.parquet")
+        out_path = os.path.join(output_dir, out_name)
+        sample.to_parquet(out_path, index=False, engine="pyarrow")
+        print(f"Wrote {nrows} rows to {out_path}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Split Parquet into small samples")
+    parser.add_argument(
+        "-i", "--input-dir",
+        default=".",
+        help="Directory with original Parquet files"
+    )
+    parser.add_argument(
+        "-p", "--pattern",
+        default="*.parquet",
+        help="Glob pattern for original Parquet files"
+    )
+    parser.add_argument(
+        "-o", "--output-dir",
+        default="sample_parquets",
+        help="Directory for sample files"
+    )
+    parser.add_argument(
+        "-n", "--nrows",
+        type=int,
+        default=10,
+        help="Number of rows per sample file"
+    )
+    args = parser.parse_args()
+
+    split_parquet(args.input_dir, args.pattern, args.output_dir, args.nrows)

test.py

@@ -0,0 +1,6 @@
+from datasets import load_dataset
+ds = load_dataset(
+    "Deepcell/parametric-cell-shapes",
+    download_mode="force_redownload"    # ensure no cache is used
+)
+print(ds)