modssc 0.2.5__tar.gz → 0.3__tar.gz

{modssc-0.2.5 → modssc-0.3}/.gitignore

@@ -44,3 +44,6 @@ log/
 coverage.xml
 analysis/
 dev_wip/
+bench/configs/experiments/article/README.md
+bench/configs/experiments/best/
+bench/configs/experiments/smoke/

{modssc-0.2.5 → modssc-0.3}/CHANGELOG.md

@@ -4,6 +4,9 @@ All notable changes to this project will be documented in this file.
 
 The format is based on "Keep a Changelog", and this project adheres to Semantic Versioning.
 
+## 0.3
+- Refactored modules to reduce redundancy, centralize shared functions, and improve maintainability and test coverage.
+
 ## 0.2.5
 - Added env var passthrough for dataset, preprocess, and runs cache directories in benchmarks.
 

{modssc-0.2.5 → modssc-0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modssc
-Version: 0.2.5
+Version: 0.3
 Summary: ModSSC: a modular framework for semi-supervised classification on heterogeneous data
 Project-URL: Homepage, https://github.com/ModSSC/ModSSC
 Project-URL: Repository, https://github.com/ModSSC/ModSSC

{modssc-0.2.5 → modssc-0.3}/docs/how-to/views.md

@@ -78,7 +78,7 @@ The view plan schema is defined in [`src/modssc/views/plan.py`](https://github.c
   <li id="source-3"><a href="https://github.com/ModSSC/ModSSC/blob/main/src/modssc/inductive/methods/co_training.py"><code>src/modssc/inductive/methods/co_training.py</code></a></li>
   <li id="source-4"><a href="https://github.com/ModSSC/ModSSC/blob/main/src/modssc/inductive/types.py"><code>src/modssc/inductive/types.py</code></a></li>
   <li id="source-5"><a href="https://github.com/ModSSC/ModSSC/blob/main/src/modssc/preprocess/plan.py"><code>src/modssc/preprocess/plan.py</code></a></li>
-  <li id="source-6"><a href="https://github.com/ModSSC/ModSSC/blob/main/bench/configs/experiments/best/inductive/co_training/text/imdb.yaml"><code>bench/configs/experiments/best/inductive/co_training/text/imdb.yaml</code></a></li>
+  <li id="source-6"><a href="https://github.com/ModSSC/ModSSC/blob/main/bench/configs/experiments/minimal/inductive/co_training/text/imdb.yaml"><code>bench/configs/experiments/minimal/inductive/co_training/text/imdb.yaml</code></a></li>
   <li id="source-7"><a href="https://github.com/ModSSC/ModSSC/blob/main/bench/schema.py"><code>bench/schema.py</code></a></li>
 </ol>
 </details>

{modssc-0.2.5 → modssc-0.3}/docs/index.md

@@ -33,7 +33,7 @@ ModSSC is a modular framework for semi-supervised classification across heteroge
 - [Transductive tutorial](tutorials/transductive-toy.md)
 
 ## Version
-Current version is `0.2.5`, sourced from [`src/modssc/__about__.py`](https://github.com/ModSSC/ModSSC/blob/main/src/modssc/__about__.py) and referenced by the Hatch version config in [`pyproject.toml`](https://github.com/ModSSC/ModSSC/blob/main/pyproject.toml). <sup class="cite"><a href="#source-18">[18]</a><a href="#source-2">[2]</a></sup>
+Current version is `0.3`, sourced from [`src/modssc/__about__.py`](https://github.com/ModSSC/ModSSC/blob/main/src/modssc/__about__.py) and referenced by the Hatch version config in [`pyproject.toml`](https://github.com/ModSSC/ModSSC/blob/main/pyproject.toml). <sup class="cite"><a href="#source-18">[18]</a><a href="#source-2">[2]</a></sup>
 
 
 ## Project status and support

{modssc-0.2.5 → modssc-0.3}/docs/reference/configuration.md

@@ -421,6 +421,6 @@ evaluation:
   <li id="source-23"><a href="https://github.com/ModSSC/ModSSC/blob/main/src/modssc/hpo/samplers.py"><code>src/modssc/hpo/samplers.py</code></a></li>
   <li id="source-24"><a href="https://github.com/ModSSC/ModSSC/blob/main/bench/configs/experiments/toy_inductive.yaml"><code>bench/configs/experiments/toy_inductive.yaml</code></a></li>
   <li id="source-25"><a href="https://github.com/ModSSC/ModSSC/blob/main/bench/configs/experiments/toy_transductive.yaml"><code>bench/configs/experiments/toy_transductive.yaml</code></a></li>
-  <li id="source-26"><a href="https://github.com/ModSSC/ModSSC/blob/main/bench/configs/experiments/best/inductive/softmatch/text/ag_news.yaml"><code>bench/configs/experiments/best/inductive/softmatch/text/ag_news.yaml</code></a></li>
+  <li id="source-26"><a href="https://github.com/ModSSC/ModSSC/blob/main/bench/configs/experiments/minimal/inductive/pseudo_label/text/imdb.yaml"><code>bench/configs/experiments/minimal/inductive/pseudo_label/text/imdb.yaml</code></a></li>
 </ol>
 </details>

{modssc-0.2.5 → modssc-0.3}/src/modssc/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2024-present ModSSC contributors
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.2.5"
+__version__ = "0.3"

{modssc-0.2.5 → modssc-0.3}/src/modssc/data_augmentation/ops/audio.py

@@ -9,6 +9,7 @@ from ..registry import register_op
 from ..types import AugmentationContext, Modality
 from ..utils import is_torch_tensor
 from .base import AugmentationOp
+from .common import apply_gaussian_noise
 
 
 @register_op("audio.add_noise")
@@ -21,22 +22,12 @@ class AddNoise(AugmentationOp):
     std: float = 0.005
 
     def apply(self, x: Any, *, rng: np.random.Generator, ctx: AugmentationContext) -> Any:  # noqa: ARG002
-        std = float(self.std)
-        if std < 0:
-            raise ValueError("std must be >= 0")
-        if std == 0:
-            return x
-        if is_torch_tensor(x):
-            import importlib
-
-            torch = importlib.import_module("torch")
-            seed = int(rng.integers(0, 1 << 31))
-            gen = torch.Generator(device=x.device).manual_seed(seed)
-            noise = torch.randn(x.shape, generator=gen, device=x.device, dtype=x.dtype) * std
-            return x + noise
-        arr = np.asarray(x)
-        noise = rng.normal(0.0, std, size=arr.shape).astype(arr.dtype, copy=False)
-        return arr + noise
+        return apply_gaussian_noise(
+            x,
+            std=float(self.std),
+            rng=rng,
+            is_torch_tensor_fn=is_torch_tensor,
+        )
 
 
 @register_op("audio.time_shift")

modssc-0.3/src/modssc/data_augmentation/ops/common.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+
+def apply_gaussian_noise(
+    x: Any,
+    *,
+    std: float,
+    rng: np.random.Generator,
+    is_torch_tensor_fn: Any,
+) -> Any:
+    std = float(std)
+    if std < 0:
+        raise ValueError("std must be >= 0")
+    if std == 0:
+        return x
+    if is_torch_tensor_fn(x):
+        import importlib
+
+        torch = importlib.import_module("torch")
+        seed = int(rng.integers(0, 1 << 31))
+        gen = torch.Generator(device=x.device).manual_seed(seed)
+        noise = torch.randn(x.shape, generator=gen, device=x.device, dtype=x.dtype) * std
+        return x + noise
+    arr = np.asarray(x)
+    noise = rng.normal(0.0, std, size=arr.shape).astype(arr.dtype, copy=False)
+    return arr + noise

{modssc-0.2.5 → modssc-0.3}/src/modssc/data_augmentation/ops/tabular.py

@@ -9,6 +9,7 @@ from ..registry import register_op
 from ..types import AugmentationContext, Modality
 from ..utils import is_torch_tensor
 from .base import AugmentationOp
+from .common import apply_gaussian_noise
 
 
 @register_op("tabular.gaussian_noise")
@@ -21,22 +22,12 @@ class GaussianNoise(AugmentationOp):
     std: float = 0.1
 
     def apply(self, x: Any, *, rng: np.random.Generator, ctx: AugmentationContext) -> Any:  # noqa: ARG002
-        std = float(self.std)
-        if std < 0:
-            raise ValueError("std must be >= 0")
-        if std == 0:
-            return x
-        if is_torch_tensor(x):
-            import importlib
-
-            torch = importlib.import_module("torch")
-            seed = int(rng.integers(0, 1 << 31))
-            gen = torch.Generator(device=x.device).manual_seed(seed)
-            noise = torch.randn(x.shape, generator=gen, device=x.device, dtype=x.dtype) * std
-            return x + noise
-        arr = np.asarray(x)
-        noise = rng.normal(0.0, std, size=arr.shape).astype(arr.dtype, copy=False)
-        return arr + noise
+        return apply_gaussian_noise(
+            x,
+            std=self.std,
+            rng=rng,
+            is_torch_tensor_fn=is_torch_tensor,
+        )
 
 
 @register_op("tabular.feature_dropout")

{modssc-0.2.5 → modssc-0.3}/src/modssc/data_augmentation/ops/text.py

@@ -32,9 +32,19 @@ class Lowercase(AugmentationOp):
         return out if many else out[0]
 
 
+class _PerItemTextOp(AugmentationOp):
+    def _apply_one(self, s: str, *, rng: np.random.Generator) -> str:
+        raise NotImplementedError
+
+    def apply(self, x: Any, *, rng: np.random.Generator, ctx: AugmentationContext) -> Any:  # noqa: ARG002
+        items, many = _as_list(x)
+        out = [self._apply_one(s, rng=rng) for s in items]
+        return out if many else out[0]
+
+
 @register_op("text.word_dropout")
 @dataclass
-class WordDropout(AugmentationOp):
+class WordDropout(_PerItemTextOp):
     """Randomly drop words from whitespace-tokenized text."""
 
     op_id: str = "text.word_dropout"
@@ -53,15 +63,10 @@ class WordDropout(AugmentationOp):
             keep = [tokens[int(rng.integers(0, len(tokens)))]]
         return " ".join(keep)
 
-    def apply(self, x: Any, *, rng: np.random.Generator, ctx: AugmentationContext) -> Any:  # noqa: ARG002
-        items, many = _as_list(x)
-        out = [self._apply_one(s, rng=rng) for s in items]
-        return out if many else out[0]
-
 
 @register_op("text.random_swap")
 @dataclass
-class RandomSwap(AugmentationOp):
+class RandomSwap(_PerItemTextOp):
     """Randomly swap two words N times."""
 
     op_id: str = "text.random_swap"
@@ -79,8 +84,3 @@ class RandomSwap(AugmentationOp):
             j = int(j)
             tokens[i], tokens[j] = tokens[j], tokens[i]
         return " ".join(tokens)
-
-    def apply(self, x: Any, *, rng: np.random.Generator, ctx: AugmentationContext) -> Any:  # noqa: ARG002
-        items, many = _as_list(x)
-        out = [self._apply_one(s, rng=rng) for s in items]
-        return out if many else out[0]

{modssc-0.2.5 → modssc-0.3}/src/modssc/data_augmentation/utils.py

@@ -5,6 +5,8 @@ from typing import Any
 
 import numpy as np
 
+from modssc.numpy_utils import to_numpy
+
 from .types import Backend
 
 
@@ -20,19 +22,6 @@ def is_torch_tensor(x: Any) -> bool:
     return hasattr(x, "shape") and hasattr(x, "dtype") and hasattr(x, "device")
 
 
-def to_numpy(x: Any) -> np.ndarray:
-    """Best-effort conversion to numpy (detaches torch tensors)."""
-    if isinstance(x, np.ndarray):
-        return x
-    if hasattr(x, "detach"):
-        x = x.detach()
-    if hasattr(x, "cpu"):
-        x = x.cpu()
-    if hasattr(x, "numpy"):
-        return x.numpy()
-    return np.asarray(x)
-
-
 def _u64_from_bytes(b: bytes) -> int:
     return int.from_bytes(b[:8], "little", signed=False)
 

{modssc-0.2.5 → modssc-0.3}/src/modssc/data_loader/cache.py

@@ -4,7 +4,6 @@ import contextlib
 import os
 import shutil
 import sqlite3
-import tempfile
 from collections.abc import Iterable, Iterator
 from contextlib import contextmanager
 from dataclasses import dataclass
@@ -15,6 +14,7 @@ from platformdirs import user_cache_dir
 
 from modssc.data_loader.errors import ManifestError
 from modssc.data_loader.manifest import Manifest, read_manifest
+from modssc.io_utils import atomic_write_text as _atomic_write_text
 
 CACHE_ENV = "MODSSC_CACHE_DIR"
 CACHE_ROOT_ENV = "MODSSC_CACHE_ROOT"
@@ -123,15 +123,7 @@ def read_cached_manifest(layout: CacheLayout, fingerprint: str) -> Manifest:
 
 
 def atomic_write_text(path: Path, text: str) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with tempfile.NamedTemporaryFile(
-        "w", delete=False, dir=str(path.parent), encoding="utf-8"
-    ) as tmp:
-        tmp.write(text)
-        tmp.flush()
-        os.fsync(tmp.fileno())
-        tmp_path = Path(tmp.name)
-    tmp_path.replace(path)
+    _atomic_write_text(path, text)
 
 
 def dir_size_bytes(path: Path) -> int:

{modssc-0.2.5 → modssc-0.3}/src/modssc/data_loader/errors.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
+from modssc.dependency_errors import MissingExtraErrorMessageMixin
+
 
 class DataLoaderError(RuntimeError):
     """Base error for modssc.data_loader."""
@@ -23,19 +25,12 @@ class ProviderNotFoundError(DataLoaderError):
 
 
 @dataclass(frozen=True)
-class OptionalDependencyError(DataLoaderError):
+class OptionalDependencyError(MissingExtraErrorMessageMixin, DataLoaderError):
     """Raised when an optional dependency (extra) required by a provider is missing."""
 
     extra: str
     purpose: str | None = None
 
-    def __str__(self) -> str:
-        msg = f"Missing optional dependency extra: {self.extra!r}."
-        if self.purpose:
-            msg += f" Required for: {self.purpose}."
-        msg += f' Install with: pip install "modssc[{self.extra}]"'
-        return msg
-
 
 class DatasetNotCachedError(DataLoaderError):
     def __init__(self, dataset_id: str) -> None:

modssc-0.3/src/modssc/data_loader/json_utils.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+
+def to_jsonable(obj: Any) -> Any:
+    if obj is None:
+        return None
+    if isinstance(obj, (bool, int, float, str)):
+        return obj
+    if isinstance(obj, Path):
+        return str(obj)
+    if isinstance(obj, np.ndarray):
+        return {"__type__": "ndarray", "shape": list(obj.shape), "dtype": str(obj.dtype)}
+    if hasattr(obj, "shape") and hasattr(obj, "dtype"):
+        try:
+            shape = list(obj.shape)
+        except Exception:
+            shape = None
+        return {
+            "__type__": type(obj).__name__,
+            "shape": shape,
+            "dtype": str(getattr(obj, "dtype", "")),
+        }
+    if isinstance(obj, Mapping):
+        return {str(k): to_jsonable(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        if len(obj) > 50:
+            return {"__type__": type(obj).__name__, "len": len(obj)}
+        return [to_jsonable(v) for v in obj]
+    return {"__type__": type(obj).__name__}
+
+
+def mapping_to_jsonable(meta: Mapping[str, Any]) -> dict[str, Any]:
+    return {str(k): to_jsonable(v) for k, v in meta.items()}

{modssc-0.2.5 → modssc-0.3}/src/modssc/data_loader/manifest.py

@@ -9,8 +9,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
-import numpy as np
-
+from modssc.data_loader.json_utils import to_jsonable as _jsonable
 from modssc.data_loader.types import DatasetIdentity, LoadedDataset
 
 
@@ -22,34 +21,6 @@ def python_version() -> str:
     return sys.version.split()[0]
 
 
-def _jsonable(obj: Any) -> Any:
-    if obj is None:
-        return None
-    if isinstance(obj, (bool, int, float, str)):
-        return obj
-    if isinstance(obj, Path):
-        return str(obj)
-    if isinstance(obj, np.ndarray):
-        return {"__type__": "ndarray", "shape": list(obj.shape), "dtype": str(obj.dtype)}
-    if hasattr(obj, "shape") and hasattr(obj, "dtype"):
-        try:
-            shape = list(obj.shape)
-        except Exception:
-            shape = None
-        return {
-            "__type__": type(obj).__name__,
-            "shape": shape,
-            "dtype": str(getattr(obj, "dtype", "")),
-        }
-    if isinstance(obj, Mapping):
-        return {str(k): _jsonable(v) for k, v in obj.items()}
-    if isinstance(obj, (list, tuple)):
-        if len(obj) > 50:
-            return {"__type__": type(obj).__name__, "len": len(obj)}
-        return [_jsonable(v) for v in obj]
-    return {"__type__": type(obj).__name__}
-
-
 def dataset_summary(ds: LoadedDataset) -> dict[str, Any]:
     def shape_dtype(x: Any) -> dict[str, Any]:
         if x is None:

modssc-0.3/src/modssc/data_loader/providers/common.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+from modssc.data_loader.types import Split
+
+
+def normalize_filter(values: Any) -> list[Any] | None:
+    if values is None:
+        return None
+    if isinstance(values, (list, tuple, set, np.ndarray)):
+        return list(values)
+    return [values]
+
+
+def apply_class_filter(
+    X: np.ndarray, y: np.ndarray, *, class_filter: list[Any] | None
+) -> tuple[np.ndarray, np.ndarray]:
+    if class_filter is None:
+        return X, y
+    mask = np.isin(y, np.asarray(class_filter))
+    return X[mask], y[mask]
+
+
+def limit_samples(
+    X: np.ndarray, y: np.ndarray, *, max_samples: int | None, seed: int | None
+) -> tuple[np.ndarray, np.ndarray]:
+    if max_samples is None:
+        return X, y
+    n = int(y.shape[0])
+    max_n = int(max_samples)
+    if max_n <= 0 or n == 0:
+        return X[:0], y[:0]
+    take = min(n, max_n)
+    idx = np.arange(n, dtype=np.int64)
+    if seed is not None:
+        rng = np.random.default_rng(int(seed))
+        rng.shuffle(idx)
+    return X[idx[:take]], y[idx[:take]]
+
+
+def apply_limits(
+    X: np.ndarray,
+    y: np.ndarray,
+    *,
+    class_filter: list[Any] | None,
+    max_samples: int | None,
+    seed: int | None,
+) -> tuple[np.ndarray, np.ndarray]:
+    X, y = apply_class_filter(X, y, class_filter=class_filter)
+    X, y = limit_samples(X, y, max_samples=max_samples, seed=seed)
+    return X, y
+
+
+def apply_limits_to_split(
+    split: Split | None,
+    *,
+    class_filter: list[Any] | None,
+    max_samples: int | None,
+    seed: int | None,
+) -> Split | None:
+    if split is None:
+        return None
+    X = np.asarray(split.X)
+    y = np.asarray(split.y)
+    X, y = apply_limits(
+        X,
+        y,
+        class_filter=class_filter,
+        max_samples=max_samples,
+        seed=seed,
+    )
+    return Split(X=X, y=y)

{modssc-0.2.5 → modssc-0.3}/src/modssc/data_loader/providers/hf.py

@@ -8,68 +8,39 @@ import numpy as np
 
 from modssc.data_loader.optional import optional_import
 from modssc.data_loader.providers.base import BaseProvider
+from modssc.data_loader.providers.common import (
+    apply_class_filter,
+    apply_limits_to_split,
+    limit_samples,
+    normalize_filter,
+)
 from modssc.data_loader.types import DatasetIdentity, LoadedDataset, Split
 from modssc.data_loader.uri import ParsedURI
 
-
-def _split_ref(ref: str) -> tuple[str, str | None]:
-    ref = ref.strip()
-    if "/" in ref:
-        name, cfg = ref.split("/", 1)
-        name = name.strip()
-        cfg = cfg.strip() or None
-        return name, cfg
-    return ref, None
-
-
-def _normalize_filter(values: Any) -> list[Any] | None:
-    if values is None:
-        return None
-    if isinstance(values, (list, tuple, set, np.ndarray)):
-        return list(values)
-    return [values]
+_apply_limits = apply_limits_to_split
+_normalize_filter = normalize_filter
 
 
 def _apply_class_filter(
     X: np.ndarray, y: np.ndarray, *, class_filter: list[Any] | None
 ) -> tuple[np.ndarray, np.ndarray]:
-    if class_filter is None:
-        return X, y
-    mask = np.isin(y, np.asarray(class_filter))
-    return X[mask], y[mask]
+    return apply_class_filter(X, y, class_filter=class_filter)
 
 
 def _limit_samples(
     X: np.ndarray, y: np.ndarray, *, max_samples: int | None, seed: int | None
 ) -> tuple[np.ndarray, np.ndarray]:
-    if max_samples is None:
-        return X, y
-    n = int(y.shape[0])
-    max_n = int(max_samples)
-    if max_n <= 0 or n == 0:
-        return X[:0], y[:0]
-    take = min(n, max_n)
-    idx = np.arange(n, dtype=np.int64)
-    if seed is not None:
-        rng = np.random.default_rng(int(seed))
-        rng.shuffle(idx)
-    return X[idx[:take]], y[idx[:take]]
-
-
-def _apply_limits(
-    split: Split | None,
-    *,
-    class_filter: list[Any] | None,
-    max_samples: int | None,
-    seed: int | None,
-) -> Split | None:
-    if split is None:
-        return None
-    X = np.asarray(split.X)
-    y = np.asarray(split.y)
-    X, y = _apply_class_filter(X, y, class_filter=class_filter)
-    X, y = _limit_samples(X, y, max_samples=max_samples, seed=seed)
-    return Split(X=X, y=y)
+    return limit_samples(X, y, max_samples=max_samples, seed=seed)
+
+
+def _split_ref(ref: str) -> tuple[str, str | None]:
+    ref = ref.strip()
+    if "/" in ref:
+        name, cfg = ref.split("/", 1)
+        name = name.strip()
+        cfg = cfg.strip() or None
+        return name, cfg
+    return ref, None
 
 
 class HuggingFaceDatasetsProvider(BaseProvider):

{modssc-0.2.5 → modssc-0.3}/src/modssc/data_loader/providers/openml.py

@@ -8,9 +8,18 @@ import numpy as np
 
 from modssc.data_loader.optional import optional_import
 from modssc.data_loader.providers.base import BaseProvider
+from modssc.data_loader.providers.common import (
+    apply_class_filter,
+    limit_samples,
+    normalize_filter,
+)
 from modssc.data_loader.types import DatasetIdentity, LoadedDataset, Split
 from modssc.data_loader.uri import ParsedURI
 
+_apply_class_filter = apply_class_filter
+_limit_samples = limit_samples
+_normalize_filter = normalize_filter
+
 
 def _parse_openml_ref(ref: str) -> dict[str, Any]:
     ref = ref.strip()
@@ -34,40 +43,6 @@ def _parse_openml_ref(ref: str) -> dict[str, Any]:
     return out
 
 
-def _normalize_filter(values: Any) -> list[Any] | None:
-    if values is None:
-        return None
-    if isinstance(values, (list, tuple, set, np.ndarray)):
-        return list(values)
-    return [values]
-
-
-def _apply_class_filter(
-    X: np.ndarray, y: np.ndarray, *, class_filter: list[Any] | None
-) -> tuple[np.ndarray, np.ndarray]:
-    if class_filter is None:
-        return X, y
-    mask = np.isin(y, np.asarray(class_filter))
-    return X[mask], y[mask]
-
-
-def _limit_samples(
-    X: np.ndarray, y: np.ndarray, *, max_samples: int | None, seed: int | None
-) -> tuple[np.ndarray, np.ndarray]:
-    if max_samples is None:
-        return X, y
-    n = int(y.shape[0])
-    max_n = int(max_samples)
-    if max_n <= 0 or n == 0:
-        return X[:0], y[:0]
-    take = min(n, max_n)
-    idx = np.arange(n, dtype=np.int64)
-    if seed is not None:
-        rng = np.random.default_rng(int(seed))
-        rng.shuffle(idx)
-    return X[idx[:take]], y[idx[:take]]
-
-
 class OpenMLProvider(BaseProvider):
     name = "openml"
     required_extra = "openml"

{modssc-0.2.5 → modssc-0.3}/src/modssc/data_loader/providers/pyg.py

@@ -9,6 +9,7 @@ import numpy as np
 
 from modssc.data_loader.optional import optional_import
 from modssc.data_loader.providers.base import BaseProvider
+from modssc.data_loader.providers.common import normalize_filter as _normalize_filter
 from modssc.data_loader.types import DatasetIdentity, LoadedDataset, Split
 from modssc.data_loader.uri import ParsedURI
 
@@ -163,14 +164,6 @@ def _to_numpy(x: Any) -> np.ndarray:
     return np.asarray(obj)
 
 
-def _normalize_filter(values: Any) -> list[Any] | None:
-    if values is None:
-        return None
-    if isinstance(values, (list, tuple, set, np.ndarray)):
-        return list(values)
-    return [values]
-
-
 def _pad_labels(y: np.ndarray, n_nodes: int) -> np.ndarray:
     if int(y.shape[0]) >= n_nodes:
         return y