Revert to 8da3023

Pipfile

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

check_json.py

@@ -1,18 +0,0 @@
-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)

dataset_infos.json

@@ -1,42 +1,29 @@
 {
   "default": {
+    "splits": {
+      "train": {
+        "num_examples": 9000
+      }
+    },
     "features": {
       "cluster": {
-        "dtype": "int64",
-        "_type": "Value"
+        "dtype": "int64"
       },
       "number": {
-        "dtype": "int64",
-        "_type": "Value"
+        "dtype": "int64"
       },
       "hfm": {
-        "feature": {
-          "dtype": "float32",
-          "_type": "Value"
-        },
-        "_type": "Sequence"
+        "dtype": "list<element: float>"
       },
       "imagenet": {
-        "feature": {
-          "dtype": "float32",
-          "_type": "Value"
-        },
-        "_type": "Sequence"
+        "dtype": "list<element: float>"
       },
       "cp": {
-        "feature": {
-          "dtype": "float64",
-          "_type": "Value"
-        },
-        "_type": "Sequence"
-      }
-    },
-    "splits": {
-      "train": {
-        "num_examples": 9000,
-        "num_bytes": 57378375
+        "dtype": "list<element: double>"
       }
     },
-    "dataset_size": 57378375
+    "supervised_keys": null,
+    "download_size": null,
+    "dataset_size": null
   }
 }

embeddings_pcs_shape_sample10.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7d1e2828016240512ae5c9fece010a389c94d2e0566cbbbd747d007855b40f9b
-size 85306

generate_info.py

@@ -1,132 +0,0 @@
-#!/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

@@ -1,54 +0,0 @@
-#!/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

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

sample_parquets/embeddings_pcs_texture_sample10.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5ecc6faad45bda889882b081ae6cfe7712e55a6caefd61af55ddb294ca8d6501
-size 85360

sample_parquets/embeddings_pcs_width_sample10.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d3cf1a5749fa3e851c828f37458c800cb6219d162c6570fd17a1a81650c4bdd8
-size 85533

split_parquet.py

@@ -1,55 +0,0 @@
-#!/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

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