Revert "code tidy"

This reverts commit 0252595.

Author: TonyBagnall

src/multiverse/__init__.py

@@ -0,0 +1,5 @@
+"""Multiverse Archive loaders and utilities."""
+
+from .datasets import list_datasets, get_spec, load_dataset
+
+__all__ = ["list_datasets", "get_spec", "load_dataset"]

src/multiverse/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

src/multiverse/datasets/__init__.py

@@ -0,0 +1,4 @@
+from ._registry import list_datasets, get_spec
+from ._load import load_dataset
+
+__all__ = ["list_datasets", "get_spec", "load_dataset"]

src/multiverse/datasets/_download.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+import requests
+from tqdm import tqdm
+
+from multiverse.utils._hash import sha256_file
+
+
+def _cache_dir() -> Path:
+    base = Path(os.environ.get("MULTIVERSE_CACHE", Path.home() / ".multiverse"))
+    d = base / "datasets"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def _zenodo_download_url(record_id: str, artifact_path: str) -> str:
+    # Simple form which works for public Zenodo records if the filename matches exactly.
+    # For robustness, you can query Zenodo's API and locate the file by filename.
+    return f"https://zenodo.org/records/{record_id}/files/{artifact_path}?download=1"
+
+
+def download_artifact(record_id: str, artifact_path: str, expected_sha256: str | None) -> Path:
+    cache = _cache_dir()
+    out = cache / artifact_path
+
+    if out.exists() and expected_sha256 and expected_sha256 != "REPLACE_ME":
+        if sha256_file(out) == expected_sha256.lower():
+            return out
+
+    url = _zenodo_download_url(record_id, artifact_path)
+    r = requests.get(url, stream=True, timeout=60)
+    r.raise_for_status()
+
+    total = int(r.headers.get("Content-Length", 0))
+    tmp = out.with_suffix(out.suffix + ".tmp")
+
+    with tmp.open("wb") as f, tqdm(total=total, unit="B", unit_scale=True, desc=f"Downloading {artifact_path}") as pbar:
+        for chunk in r.iter_content(chunk_size=1024 * 1024):
+            if chunk:
+                f.write(chunk)
+                pbar.update(len(chunk))
+
+    tmp.replace(out)
+
+    if expected_sha256 and expected_sha256 != "REPLACE_ME":
+        got = sha256_file(out)
+        if got.lower() != expected_sha256.lower():
+            out.unlink(missing_ok=True)
+            raise ValueError(
+                f"Checksum mismatch for {artifact_path}. Expected {expected_sha256}, got {got}."
+            )
+
+    return out

src/multiverse/datasets/_load.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from pathlib import Path
+import zipfile
+
+from aeon.datasets import load_from_tsfile
+
+from multiverse.datasets._registry import get_spec
+from multiverse.datasets._download import download_artifact
+
+
+def load_dataset(name: str, split: str = "train"):
+    """Load a dataset split into aeon-compatible X, y.
+
+    Assumes the Zenodo artefact is a zip containing `<NAME>_TRAIN.ts` and `<NAME>_TEST.ts`.
+    """
+    spec = get_spec(name)
+    if spec.zenodo_record_id == "REPLACE_ME":
+        raise ValueError(
+            "Dataset registry contains placeholders. Replace zenodo_record_id and sha256 in mtsc_registry.csv."
+        )
+
+    zip_path = download_artifact(spec.zenodo_record_id, spec.artifact_path, spec.sha256)
+
+    split = split.lower()
+    if split not in {"train", "test"}:
+        raise ValueError("split must be 'train' or 'test'")
+
+    with zipfile.ZipFile(zip_path) as zf:
+        target = f"{spec.dataset}_{split.upper()}.ts"
+        members = [m for m in zf.namelist() if m.endswith(target)]
+        if not members:
+            raise FileNotFoundError(f"Could not find {target} inside {spec.artifact_path}")
+        ts_member = members[0]
+
+        extract_dir = zip_path.with_suffix("")  # e.g. ~/.multiverse/datasets/BasicMotions/
+        extract_dir.mkdir(exist_ok=True)
+        out_path = extract_dir / Path(ts_member).name
+        if not out_path.exists():
+            zf.extract(ts_member, path=extract_dir)
+            extracted = extract_dir / ts_member
+            if extracted != out_path:
+                extracted.replace(out_path)
+
+    X, y = load_from_tsfile(str(out_path))
+    return X, y

src/multiverse/datasets/_registry.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from importlib.resources import files
+import pandas as pd
+
+
+@dataclass(frozen=True)
+class DatasetSpec:
+    dataset: str
+    zenodo_record_id: str
+    artifact_path: str
+    sha256: str
+    format: str
+    notes: str
+    licence: str
+
+
+def load_registry() -> pd.DataFrame:
+    reg_path = files("multiverse").joinpath("datasets/mtsc_registry.csv")
+    return pd.read_csv(reg_path)
+
+
+def get_spec(name: str) -> DatasetSpec:
+    df = load_registry()
+    row = df.loc[df["dataset"].str.lower() == name.lower()]
+    if row.empty:
+        raise KeyError(f"Unknown dataset: {name}. Use list_datasets().")
+    r = row.iloc[0].to_dict()
+    return DatasetSpec(**r)
+
+
+def list_datasets() -> list[str]:
+    df = load_registry()
+    return sorted(df["dataset"].tolist())

src/multiverse/datasets/mtsc_registry.csv

@@ -0,0 +1,3 @@
+dataset,zenodo_record_id,artifact_path,sha256,format,notes,licence
+BasicMotions,REPLACE_ME,BasicMotions.zip,REPLACE_ME,tszip,UEA MTSC classic,CC-BY-4.0
+NATOPS,REPLACE_ME,NATOPS.zip,REPLACE_ME,tszip,UEA MTSC classic,CC-BY-4.0

src/multiverse/utils/__init__.py

@@ -0,0 +1 @@
+

src/multiverse/utils/_hash.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+
+
+def sha256_file(path: str | Path, chunk_size: int = 1024 * 1024) -> str:
+    h = hashlib.sha256()
+    p = Path(path)
+    with p.open("rb") as f:
+        for chunk in iter(lambda: f.read(chunk_size), b""):
+            h.update(chunk)
+    return h.hexdigest()