nltools 0.6.0.dev0__py3-none-any.whl

nltools/templates/config.py

@@ -0,0 +1,144 @@
+"""Global brain-space configuration: frozen dataclass + set/get/with API."""
+
+from contextlib import contextmanager
+from dataclasses import dataclass, replace
+from collections.abc import Iterator
+
+from .paths import _resolve_paths
+from .registry import SUPPORTED_RESOLUTIONS, TemplateName, Resolution
+
+
+@dataclass(frozen=True)
+class BrainSpaceConfig:
+    """Immutable MNI template configuration.
+
+    Attributes:
+        template (str): Template variant (`'default'`, `'nilearn'`, `'fmriprep'`).
+        resolution (int): Resolution in mm (1, 2, or 3).
+        mask (str): Path to the brain mask file.
+        brain (str): Path to the brain-extracted image.
+        plot (str): Path to the full T1 image used for plotting.
+    """
+
+    template: TemplateName = "default"
+    resolution: Resolution = 2
+
+    def __post_init__(self) -> None:
+        if self.template not in SUPPORTED_RESOLUTIONS:
+            raise ValueError(
+                f"Unknown template: {self.template!r}. "
+                f"Supported: {sorted(SUPPORTED_RESOLUTIONS)}"
+            )
+        if self.resolution not in SUPPORTED_RESOLUTIONS[self.template]:
+            raise ValueError(
+                f"Resolution {self.resolution}mm not supported for "
+                f"{self.template!r}. "
+                f"Supported: {SUPPORTED_RESOLUTIONS[self.template]}"
+            )
+
+    @property
+    def mask(self) -> str:
+        """Path to the brain mask file."""
+        return _resolve_paths(self.template, self.resolution)["mask"]
+
+    @property
+    def brain(self) -> str:
+        """Path to the brain-extracted image."""
+        return _resolve_paths(self.template, self.resolution)["brain"]
+
+    @property
+    def plot(self) -> str:
+        """Path to the full T1 image used for plotting."""
+        return _resolve_paths(self.template, self.resolution)["plot"]
+
+    def __repr__(self) -> str:
+        import os
+
+        return (
+            f"BrainSpaceConfig(template={self.template!r}, "
+            f"resolution={self.resolution}mm)\n"
+            f"  mask: {os.path.basename(self.mask)}\n"
+            f"  brain: {os.path.basename(self.brain)}\n"
+            f"  plot: {os.path.basename(self.plot)}"
+        )
+
+
+_DEFAULT = BrainSpaceConfig()
+_current: BrainSpaceConfig = _DEFAULT
+
+
+def get_brainspace() -> BrainSpaceConfig:
+    """Return the current global brain-space configuration.
+
+    Returns:
+        BrainSpaceConfig: The active configuration.
+    """
+    return _current
+
+
+def set_brainspace(
+    template: TemplateName | None = None,
+    resolution: Resolution | None = None,
+) -> BrainSpaceConfig:
+    """Set the global brain-space configuration.
+
+    Call with no arguments to return the current config without mutating it.
+    Call with one or both arguments to mutate the global state; unspecified
+    fields retain their current value.
+
+    Args:
+        template (str, optional): Template name to set (`'default'`, `'nilearn'`,
+            `'fmriprep'`). If None, keeps the current value.
+        resolution (int, optional): Resolution in mm to set. If None, keeps the
+            current value.
+
+    Returns:
+        BrainSpaceConfig: The new (or unchanged) current configuration.
+    """
+    global _current
+    if template is None and resolution is None:
+        return _current
+    updates: dict[str, object] = {}
+    if template is not None:
+        updates["template"] = template
+    if resolution is not None:
+        updates["resolution"] = resolution
+    _current = replace(_current, **updates)
+    return _current
+
+
+def reset_brainspace() -> BrainSpaceConfig:
+    """Reset the global brain-space configuration to defaults.
+
+    Returns:
+        BrainSpaceConfig: The default configuration (`'default'` template, 2 mm).
+    """
+    global _current
+    _current = _DEFAULT
+    return _current
+
+
+@contextmanager
+def with_brainspace(
+    template: TemplateName | None = None,
+    resolution: Resolution | None = None,
+) -> Iterator[BrainSpaceConfig]:
+    """Temporarily change the global brain-space configuration.
+
+    Restores the previous configuration on exit, even if an exception is
+    raised inside the block.
+
+    Args:
+        template (str, optional): Template name for the duration of the block.
+        resolution (int, optional): Resolution in mm for the duration of the block.
+
+    Yields:
+        BrainSpaceConfig: The configuration active inside the block.
+    """
+    global _current
+    previous = _current
+    try:
+        set_brainspace(template=template, resolution=resolution)
+        yield _current
+    finally:
+        _current = previous

nltools/templates/fetch.py

@@ -0,0 +1,260 @@
+"""Lazy fetcher for files hosted in the `nltools/niftis` HF dataset.
+
+Covers MNI templates, parcellation label maps, the parcel-names CSV, and
+any other resources living under huggingface.co/datasets/nltools/niftis.
+First call for a given file downloads it into the local HF cache
+(`~/.cache/huggingface/hub` by default); subsequent calls return the
+cached path without touching the network.
+
+In Pyodide `hf_hub_download` is unusable: it HEAD-probes the resolve URL for
+metadata, and both Pyodide HTTP backends dereference the body of that bodiless
+response and crash. The browser path therefore skips the client and does a
+direct GET (`pyodide.http.pyfetch`) into an IDBFS-backed cache directory, which
+survives a page reload. Where the browser has no JavaScript Promise Integration
+to bridge that async fetch back to a synchronous call, a `requests` GET stands
+in and the cache is session-only — a page reload downloads again. Same repo,
+same revision, same memoization either way; only the transport differs.
+"""
+
+import functools
+import sys
+from pathlib import Path
+
+REPO_ID = "nltools/niftis"
+REVISION = "main"
+
+# Mount point for the Pyodide cache. IDBFS is mounted at the parent so the
+# whole tree lands in one IndexedDB store. Outside Pyodide this is unused;
+# huggingface_hub manages its own cache under ~/.cache/huggingface.
+_PYODIDE_CACHE_ROOT = Path("/nltools_cache") / REVISION
+
+# IDBFS can only be mounted once per Pyodide instance.
+_idbfs_mounted = False
+
+
+@functools.cache
+def fetch_resource(relpath: str) -> str:
+    """Return a local path to a file from the `nltools/niftis` HF dataset.
+
+    Args:
+        relpath (str): Path within the dataset repo, e.g.
+            `'default/2mm-MNI152-2009fsl-mask.nii.gz'` or
+            `'masks/k88_parcel_names.csv'`. Use `list_resources`
+            to enumerate what's available.
+
+    Returns:
+        str: Absolute path to the cached file on disk. The returned path drops
+            straight into anything that takes a NIfTI path — nilearn plotting
+            and masking helpers, `nibabel.load`, and `BrainData(path)`.
+
+    Note:
+        Resolution is memoized per `relpath` for the session — repeated
+        calls (e.g. every default-mask `BrainData` construction) return the
+        cached path with no work. A file already in the HF cache is resolved
+        offline, so only a genuine cache miss touches the network. Under
+        Pyodide the file comes from an IndexedDB-backed cache instead, which
+        persists across page reloads.
+    """
+    if "pyodide" in sys.modules:
+        return _fetch_pyodide(relpath)
+
+    from huggingface_hub import hf_hub_download
+    from huggingface_hub.utils import LocalEntryNotFoundError
+
+    try:
+        return hf_hub_download(
+            repo_id=REPO_ID,
+            filename=relpath,
+            repo_type="dataset",
+            revision=REVISION,
+            local_files_only=True,
+        )
+    except LocalEntryNotFoundError:
+        return hf_hub_download(
+            repo_id=REPO_ID,
+            filename=relpath,
+            repo_type="dataset",
+            revision=REVISION,
+        )
+
+
+@functools.lru_cache(maxsize=8)
+def _list_repo_files_cached(repo_id: str, revision: str) -> tuple[str, ...]:
+    """Single HF API hit per (repo, revision) for the session."""
+    from huggingface_hub import HfApi
+
+    files = HfApi().list_repo_files(
+        repo_id=repo_id, repo_type="dataset", revision=revision
+    )
+    return tuple(sorted(files))
+
+
+def list_resources(prefix: str | None = None) -> list[str]:
+    """List files available in the `nltools/niftis` HF dataset.
+
+    Companion to `fetch_resource` — surfaces what's downloadable
+    without forcing users to remember relpath strings or visit the HF
+    web UI.
+
+    Args:
+        prefix (str, optional): Path prefix to filter by (e.g. `'masks/'`,
+            `'default/'`, `'fmriprep/'`). Matches with `str.startswith`.
+
+    Returns:
+        list[str]: Sorted relative paths usable with `fetch_resource`.
+
+    Note:
+        Hits the HF API once per session (cached). Under Pyodide this needs
+        `httpcore` installed — `huggingface_hub`'s client imports it lazily and
+        nothing else in the browser environment pulls it in, so run
+        `await micropip.install("httpcore")` first.
+    """
+    files = _list_repo_files_cached(REPO_ID, REVISION)
+    if prefix:
+        return [f for f in files if f.startswith(prefix)]
+    return list(files)
+
+
+def _fetch_pyodide(relpath: str) -> str:
+    """Return a cached path in the browser, downloading on a cache miss.
+
+    Two transports, chosen by what the browser supports. With JavaScript
+    Promise Integration, `pyodide.ffi.run_sync` drives an async `pyfetch` and
+    the cache is IDBFS-backed, so it survives a page reload. Without it — an
+    older browser, or a synchronous entry point that cannot stack-switch — a
+    `requests` GET does the same job into a plain in-memory cache. Either way
+    `fetch_resource` keeps the signature it has everywhere else.
+    """
+    from pyodide.ffi import can_run_sync, run_sync
+
+    if can_run_sync():
+        return run_sync(_download_pyodide(relpath))
+    return _download_pyodide_sync(relpath)
+
+
+async def _download_pyodide(relpath: str) -> str:
+    """Fetch one dataset file into the IDBFS cache with a direct GET."""
+    await _ensure_idbfs_mounted()
+
+    target = _PYODIDE_CACHE_ROOT / relpath
+    if target.exists():
+        return str(target)
+
+    from pyodide.http import pyfetch
+
+    url = _resource_url(relpath)
+    response = await pyfetch(url)
+    _check_status(response.status, relpath, url)
+    path = _write_cached(target, await response.bytes())
+    await _flush_idbfs()
+    return path
+
+
+def _download_pyodide_sync(relpath: str) -> str:
+    """Fetch one dataset file with `requests`, into a session-only cache.
+
+    The fallback for a browser without Promise Integration. Mounting IDBFS
+    needs an await of its own, so this path stays on the in-memory filesystem
+    and a page reload downloads again.
+    """
+    target = _PYODIDE_CACHE_ROOT / relpath
+    if target.exists():
+        return str(target)
+
+    try:
+        import requests
+    except ImportError as error:
+        raise RuntimeError(
+            "Downloading nltools data in this browser needs either JavaScript "
+            "Promise Integration (call from an async notebook cell) or "
+            "`requests` — run `await micropip.install('requests')`."
+        ) from error
+
+    url = _resource_url(relpath)
+    response = requests.get(url, timeout=60)
+    _check_status(response.status_code, relpath, url)
+    return _write_cached(target, response.content)
+
+
+def _resource_url(relpath: str) -> str:
+    """Build the HF resolve URL both browser transports GET."""
+    return f"https://huggingface.co/datasets/{REPO_ID}/resolve/{REVISION}/{relpath}"
+
+
+def _check_status(status: int, relpath: str, url: str) -> None:
+    """Raise unless the download returned 200."""
+    if status != 200:
+        raise RuntimeError(
+            f"Could not download {relpath!r} from {REPO_ID}: HTTP {status} for {url}"
+        )
+
+
+def _write_cached(target: Path, payload: bytes) -> str:
+    """Write `payload` to `target` atomically and return the path.
+
+    A write that dies partway would otherwise leave a short file that every
+    later call serves as a cache hit — and that `_flush_idbfs` may already have
+    pushed into IndexedDB, where only wiping site data clears it. Renaming a
+    fully written sibling into place is atomic on Emscripten's filesystem.
+    """
+    target.parent.mkdir(parents=True, exist_ok=True)
+    partial = target.with_name(target.name + ".part")
+    try:
+        partial.write_bytes(payload)
+        partial.replace(target)
+    finally:
+        partial.unlink(missing_ok=True)
+    return str(target)
+
+
+async def _ensure_idbfs_mounted() -> None:
+    """Mount IDBFS at the cache root and load any prior data. Idempotent."""
+    global _idbfs_mounted
+    if _idbfs_mounted:
+        return
+
+    import js
+    import pyodide_js
+
+    mount_point = str(_PYODIDE_CACHE_ROOT.parent)
+    Path(mount_point).mkdir(parents=True, exist_ok=True)
+
+    fs = pyodide_js.FS
+    # `FS.mount` wants a JS object for its options; a Python dict arrives as a
+    # proxy the Emscripten filesystem cannot read.
+    fs.mount(fs.filesystems.IDBFS, js.Object.new(), mount_point)
+    # The mount is what must not be repeated: a second mount of a live point
+    # raises a bare Emscripten error. A failed populate costs the prior cache,
+    # not the mount, so the flag flips here rather than after the sync.
+    _idbfs_mounted = True
+    await _syncfs(populate=True)
+
+
+async def _flush_idbfs() -> None:
+    """Push MEMFS writes back to IndexedDB."""
+    await _syncfs(populate=False)
+
+
+async def _syncfs(*, populate: bool) -> None:
+    """Wrap the Emscripten `FS.syncfs` callback in an awaitable."""
+    import asyncio
+
+    import pyodide_js
+    from pyodide.ffi import create_proxy
+
+    done: asyncio.Future = asyncio.get_running_loop().create_future()
+
+    def callback(err):
+        # Success passes JS `null`, which Pyodide surfaces as `JsNull` rather
+        # than `None` — falsy either way, and an error object is truthy.
+        if err:
+            done.set_exception(RuntimeError(f"FS.syncfs failed: {err}"))
+        else:
+            done.set_result(None)
+
+    proxy = create_proxy(callback)
+    try:
+        pyodide_js.FS.syncfs(populate, proxy)
+        await done
+    finally:
+        proxy.destroy()

nltools/templates/matching.py

@@ -0,0 +1,183 @@
+"""Affine-based template matching and background-image selection."""
+
+import warnings
+from dataclasses import dataclass
+
+import numpy as np
+
+from nltools.utils import ResamplingWarning, _find_stack_level
+
+from .config import get_brainspace
+from .paths import _resolve_paths
+from .registry import SUPPORTED_RESOLUTIONS, TEMPLATE_PRIORITY
+
+
+@dataclass(frozen=True)
+class _TemplateMatch:
+    """Result of matching a data affine to a template.
+
+    Attributes:
+        template (str): Best-matching template name.
+        resolution (int): Best-matching resolution in mm.
+        mask_path (str): Path to the matched mask file.
+    """
+
+    template: str
+    resolution: int
+    mask_path: str
+
+
+def _detect_resolution(affine: np.ndarray) -> tuple[float, bool]:
+    """Detect voxel resolution (mm) and isotropy from a NIfTI affine.
+
+    Voxels are treated as isotropic when the per-axis sizes agree to within
+    three decimals. The reported resolution is that shared isotropic size, or
+    the mean of the per-axis sizes when non-isotropic.
+
+    Args:
+        affine (np.ndarray): 4x4 affine matrix from a NIfTI image.
+
+    Returns:
+        tuple[float, bool]: `(resolution_mm, is_isotropic)`.
+    """
+    res_array = np.abs(np.diag(affine[:3, :3]))
+    voxel_dims = np.unique(np.round(res_array, 3))
+    is_isotropic = len(voxel_dims) == 1
+    resolution_mm = float(voxel_dims[0]) if is_isotropic else float(np.mean(res_array))
+    return resolution_mm, is_isotropic
+
+
+def _match_resolution(
+    affine: np.ndarray,
+    warn_resample: bool = True,
+) -> _TemplateMatch:
+    """Find the best matching template for a given affine matrix.
+
+    Searches available templates by priority and returns the one whose
+    resolution most closely matches the data's voxel size.
+
+    Args:
+        affine (np.ndarray): 4x4 affine matrix from a NIfTI image.
+        warn_resample (bool): If True, emit a `ResamplingWarning` when the data
+            resolution has no exact template and the closest one is used. Default
+            True.
+
+    Returns:
+        _TemplateMatch: The selected template, its resolution, and its mask path.
+
+    Raises:
+        ValueError: If detected resolution is outside a reasonable range.
+    """
+    resolution_float, _ = _detect_resolution(affine)
+    resolution = int(np.round(resolution_float))
+
+    if resolution < 1 or resolution > 10:
+        raise ValueError(
+            f"Detected resolution ({resolution_float}mm) is outside "
+            f"reasonable range (1-10mm). Data may not be in standard MNI space."
+        )
+
+    best_template: str | None = None
+    best_resolution: int | None = None
+
+    for tmpl in TEMPLATE_PRIORITY:
+        if resolution in SUPPORTED_RESOLUTIONS[tmpl]:
+            best_template, best_resolution = tmpl, resolution
+            break
+
+    if best_template is None:
+        all_res = {r for res in SUPPORTED_RESOLUTIONS.values() for r in res}
+        closest = min(all_res, key=lambda x: abs(x - resolution))
+        best_distance = float(abs(closest - resolution))
+        for tmpl in TEMPLATE_PRIORITY:
+            if closest in SUPPORTED_RESOLUTIONS[tmpl]:
+                best_template, best_resolution = tmpl, closest
+                break
+        if best_distance > 0 and warn_resample:
+            warnings.warn(
+                f"Data resolution ({resolution_float:.3f}mm) does not match any "
+                f"bundled MNI template; the closest is {best_template} "
+                f"{best_resolution}mm, so the data will be resampled to that grid. "
+                "To keep the native resolution, pass mask= with a mask in the "
+                "data's own space.",
+                ResamplingWarning,
+                stacklevel=_find_stack_level(),
+            )
+
+    assert best_template is not None and best_resolution is not None
+    paths = _resolve_paths(best_template, best_resolution)
+    return _TemplateMatch(
+        template=best_template,
+        resolution=best_resolution,
+        mask_path=paths["mask"],
+    )
+
+
+def _is_standard_space(affine: np.ndarray) -> tuple[bool, str | None]:
+    """Check whether an affine is compatible with our MNI templates.
+
+    A "standard space" affine has isotropic voxels at one of the supported
+    template resolutions (the union of `SUPPORTED_RESOLUTIONS`). Plotting
+    surfaces (glass brain, flatmap, surface montage) and template-driven
+    background lookup all assume this — non-isotropic or off-grid data
+    would render in misleading positions.
+
+    Args:
+        affine (np.ndarray): 4x4 affine matrix from a NIfTI image (typically
+            `bd.mask.affine`).
+
+    Returns:
+        tuple[bool, str | None]: `(True, None)` if compatible; otherwise
+            `(False, reason)` with `reason` a one-line human-readable explanation
+            suitable for embedding in an error message.
+    """
+    res, is_isotropic = _detect_resolution(affine)
+    if not is_isotropic:
+        res_array = np.abs(np.diag(affine[:3, :3]))
+        zooms = tuple(round(float(r), 2) for r in res_array)
+        return False, f"voxels are non-isotropic (zooms={zooms} mm)"
+    res_int = int(round(res))
+    if abs(res - res_int) > 1e-3:
+        return False, (
+            f"voxel size {res:.3f}mm is not an integer-mm template resolution"
+        )
+    all_supported = sorted({r for rs in SUPPORTED_RESOLUTIONS.values() for r in rs})
+    if res_int not in all_supported:
+        return False, (
+            f"voxel size {res_int}mm is not a supported MNI template "
+            f"resolution (supported: {all_supported}mm)"
+        )
+    return True, None
+
+
+def _get_bg_image(affine: np.ndarray) -> str:
+    """Get a brain-extracted background image path matching a data resolution.
+
+    Uses the current global brain space and finds the matching resolution from
+    the affine. Used by plotting functions to pick an appropriate background
+    anatomical.
+
+    Args:
+        affine (np.ndarray): 4x4 affine matrix from a BrainData's masker.
+
+    Returns:
+        str: Path to the template image file.
+
+    Raises:
+        ValueError: If voxels are non-isotropic.
+    """
+    cfg = get_brainspace()
+
+    resolution_float, is_isotropic = _detect_resolution(affine)
+    if not is_isotropic:
+        raise ValueError(
+            "Voxels are not isotropic and cannot be visualized in standard space"
+        )
+
+    resolution = int(round(resolution_float))
+
+    if resolution not in SUPPORTED_RESOLUTIONS.get(cfg.template, []):
+        return cfg.brain
+
+    paths = _resolve_paths(cfg.template, resolution)
+    return paths["brain"]

nltools/templates/paths.py

@@ -0,0 +1,106 @@
+"""Pure path-resolution helpers for MNI template files.
+
+Resolves logical (template, resolution, file_type) tuples to local paths.
+Files are fetched on first use from the `nltools/niftis` HF dataset; see
+`nltools.templates.fetch`.
+"""
+
+from .fetch import fetch_resource
+from .registry import SUPPORTED_RESOLUTIONS, VERSION_MAP, VERSION_TO_TEMPLATE
+
+_TEMPLATE_NAME_STEM = "mm-MNI152-2009"
+
+
+def _split_template_name(template_name: str) -> tuple[int, str] | None:
+    """Split `'{res}mm-MNI152-2009{code}'` into its resolution and version code.
+
+    This is the only parser for template-name strings; callers that merely need
+    to recognize one check the result against `None`.
+
+    Args:
+        template_name (str): Candidate template name, e.g. `'2mm-MNI152-2009c'`.
+
+    Returns:
+        tuple[int, str] | None: `(resolution_mm, version_code)`, or None when the
+            string does not have the template-name shape. The version code is not
+            validated here; look it up in `VERSION_TO_TEMPLATE`.
+    """
+    resolution, stem, version_code = template_name.partition(_TEMPLATE_NAME_STEM)
+    if not stem or not resolution.isdecimal() or not version_code:
+        return None
+    return int(resolution), version_code
+
+
+def _resolve_paths(template: str, resolution: int) -> dict[str, str]:
+    """Build mask/brain/plot paths for a template + resolution.
+
+    Args:
+        template (str): Template name (`'default'`, `'nilearn'`, `'fmriprep'`).
+        resolution (int): Resolution in mm.
+
+    Returns:
+        dict[str, str]: Local file paths keyed `'mask'`, `'brain'`, `'plot'`.
+
+    Raises:
+        ValueError: If template or resolution is invalid.
+    """
+    if template not in VERSION_MAP:
+        raise ValueError(
+            f"Unknown template: {template!r}. Supported: {sorted(VERSION_MAP)}"
+        )
+    if resolution not in SUPPORTED_RESOLUTIONS.get(template, []):
+        raise ValueError(
+            f"Resolution {resolution}mm not supported for {template!r}. "
+            f"Supported: {SUPPORTED_RESOLUTIONS[template]}"
+        )
+
+    version = VERSION_MAP[template]
+    res_str = f"{resolution}mm"
+
+    return {
+        key: fetch_resource(
+            f"{template}/{res_str}-MNI152-2009{version}-{file_type}.nii.gz"
+        )
+        for file_type, key in [("mask", "mask"), ("brain", "brain"), ("T1", "plot")]
+    }
+
+
+def _resolve_template_name(template_name: str, file_type: str = "mask") -> str:
+    """Resolve a template name string to a file path.
+
+    Supports names of the form `'{res}mm-MNI152-2009{version}'`.
+
+    Args:
+        template_name (str): e.g. `'2mm-MNI152-2009c'`, `'3mm-MNI152-2009a'`.
+        file_type (str): `'mask'`, `'brain'`, or `'T1'`. Default `'mask'`.
+
+    Returns:
+        str: Absolute path to the requested template file.
+
+    Raises:
+        ValueError: If `file_type` or the template name format is invalid.
+    """
+    if file_type not in ("mask", "brain", "T1"):
+        raise ValueError(
+            f"file_type must be 'mask', 'brain', or 'T1'. Got: {file_type!r}"
+        )
+
+    parsed = _split_template_name(template_name)
+    if parsed is None:
+        raise ValueError(
+            f"Invalid template name format: {template_name!r}. "
+            f"Expected: '{{res}}mm-MNI152-2009{{version}}' "
+            f"(e.g., '2mm-MNI152-2009c', '3mm-MNI152-2009a', '2mm-MNI152-2009fsl')"
+        )
+
+    resolution, version_code = parsed
+
+    if version_code not in VERSION_TO_TEMPLATE:
+        raise ValueError(
+            f"Unknown version code {version_code!r} in {template_name!r}. "
+            f"Supported: 'fsl' (default), 'a' (nilearn), 'c' (fmriprep)"
+        )
+
+    template = VERSION_TO_TEMPLATE[version_code]
+    key = "plot" if file_type == "T1" else file_type
+    return _resolve_paths(template, resolution)[key]