meds-algorithm 0.4.0a4__py3-none-any.whl

meds_algorithm/requests.py

@@ -0,0 +1,262 @@
+"""One typed request per operation. Field metadata defines the existing CLI path names."""
+
+from __future__ import annotations
+
+from dataclasses import MISSING, dataclass, field, fields
+from pathlib import Path
+from typing import ClassVar, get_args, get_type_hints
+
+from .artifacts.references import (
+    ArtifactDestination,
+    ArtifactReference,
+    EmbeddingsArtifact,
+    FinetunedAlgorithmArtifact,
+    PredictionsArtifact,
+    PreparedDataArtifact,
+    PretrainedAlgorithmArtifact,
+    ProbeAlgorithmArtifact,
+    SupervisedAlgorithmArtifact,
+    TrajectoriesArtifact,
+)
+from .configuration import ExecutionOptions
+from .serialization import Serializable
+from .tasks.spec import TaskSpec
+
+
+@dataclass(frozen=True)
+class PredictionIndex(Serializable):
+    directory: Path
+    splits: tuple[str, ...]
+
+    def validate(self):
+        if (
+            not self.splits
+            or len(set(self.splits)) != len(self.splits)
+            or any(not s.strip() for s in self.splits)
+        ):
+            raise ValueError("splits must be a nonempty tuple of unique names")
+
+    def read(self):
+        from .data.index import read_index
+
+        return read_index(self.directory, self.splits)
+
+
+@dataclass(frozen=True)
+class TrainingLabels(Serializable):
+    directory: Path
+
+    def read(self, split: str = "train"):
+        from .data.labels import read_targets
+
+        if split not in ("train", "tuning"):
+            raise ValueError("Training labels permit only train and tuning")
+        return read_targets(self.directory, (split,))
+
+
+@dataclass(frozen=True)
+class PredictionContext(Serializable):
+    directory: Path
+    splits: tuple[str, ...]
+
+    def validate(self):
+        if (
+            not self.splits
+            or len(set(self.splits)) != len(self.splits)
+            or set(self.splits) - {"train", "tuning"}
+        ):
+            raise ValueError("Context splits must explicitly select train and/or tuning")
+
+    def read(self, index: PredictionIndex):
+        from .data.labels import read_context_labels
+
+        return read_context_labels(
+            self.directory, self.splits, index.splits, evaluation_index_dir=index.directory
+        )
+
+
+@dataclass(frozen=True, kw_only=True)
+class StepRequest(Serializable):
+    output: ArtifactDestination
+    execution: ExecutionOptions = field(default_factory=ExecutionOptions)
+    predicates_file: Path | None = field(default=None, metadata={"argument": "external_predicates_file"})
+    output_argument: ClassVar[str]
+    result_type: ClassVar[type[ArtifactReference]]
+
+    @classmethod
+    def argument_fields(cls):
+        hints = get_type_hints(cls)
+        return [(f, hints[f.name]) for f in fields(cls)]
+
+    @classmethod
+    def from_arguments(cls, arguments: dict):
+        values = dict(arguments)
+        output = values.pop(cls.output_argument, None)
+        if output is None:
+            raise ValueError(f"requires {cls.output_argument}=<path>")
+        result = {
+            "output": {"directory": output},
+            "execution": {"overwrite": values.pop("do_overwrite", False), "seed": values.pop("seed", 0)},
+        }
+        for f, annotation in cls.argument_fields():
+            if f.name in ("output", "execution"):
+                continue
+            kind = next((t for t in get_args(annotation) if t is not type(None)), annotation)
+            key = f.metadata.get("argument")
+            if key and key in values:
+                value = values.pop(key)
+                result[f.name] = (
+                    {"directory": value}
+                    if isinstance(kind, type) and issubclass(kind, (ArtifactReference, TrainingLabels))
+                    else value
+                )
+            elif kind is PredictionIndex and "external_index_dir" in values:
+                result[f.name] = {
+                    "directory": values.pop("external_index_dir"),
+                    "splits": values.pop("splits", None),
+                }
+            elif kind is PredictionContext and "external_labels_dir" in values:
+                result[f.name] = {
+                    "directory": values.pop("external_labels_dir"),
+                    "splits": values.pop("context_splits", None),
+                }
+            elif kind is TaskSpec and "external_task_criteria_file" in values:
+                result[f.name] = {
+                    "criteria_file": values.pop("external_task_criteria_file"),
+                    "predicates_file": arguments.get("external_predicates_file"),
+                    "name": values.pop("task_name", None),
+                }
+        if values:
+            raise ValueError(f"Unknown or forbidden arguments for {cls.__name__}: {sorted(values)}")
+        for f, _annotation in cls.argument_fields():
+            if f.default is MISSING and f.default_factory is MISSING and f.name not in result:
+                required = f.metadata.get(
+                    "argument",
+                    {
+                        "index": "external_index_dir and splits",
+                        "task": "external_task_criteria_file",
+                    }.get(f.name, f.name),
+                )
+                raise ValueError(f"requires {required}")
+        return cls.from_dict(result)
+
+    def artifact_inputs(self):
+        for f in fields(self):
+            value = getattr(self, f.name)
+            if isinstance(value, ArtifactReference):
+                yield f.metadata["argument"], value
+
+
+@dataclass(frozen=True, kw_only=True)
+class PreprocessDataRequest(StepRequest):
+    meds_dir: Path = field(metadata={"argument": "external_meds_dir"})
+    output_argument = "output_data_dir"
+    result_type = PreparedDataArtifact
+
+
+@dataclass(frozen=True, kw_only=True)
+class PretrainRequest(StepRequest):
+    data: PreparedDataArtifact = field(metadata={"argument": "input_data_dir"})
+    output_argument = "output_pretrained_algorithm_dir"
+    result_type = PretrainedAlgorithmArtifact
+
+
+@dataclass(frozen=True, kw_only=True)
+class TrainSupervisedRequest(StepRequest):
+    data: PreparedDataArtifact = field(metadata={"argument": "input_data_dir"})
+    labels: TrainingLabels = field(metadata={"argument": "external_labels_dir"})
+    output_argument = "output_supervised_algorithm_dir"
+    result_type = SupervisedAlgorithmArtifact
+
+
+@dataclass(frozen=True, kw_only=True)
+class TrainFinetuneRequest(StepRequest):
+    data: PreparedDataArtifact = field(metadata={"argument": "input_data_dir"})
+    pretrained: PretrainedAlgorithmArtifact = field(metadata={"argument": "input_pretrained_algorithm_dir"})
+    labels: TrainingLabels = field(metadata={"argument": "external_labels_dir"})
+    output_argument = "output_finetuned_algorithm_dir"
+    result_type = FinetunedAlgorithmArtifact
+
+
+@dataclass(frozen=True, kw_only=True)
+class InferEmbeddingsRequest(StepRequest):
+    data: PreparedDataArtifact = field(metadata={"argument": "input_data_dir"})
+    pretrained: PretrainedAlgorithmArtifact = field(metadata={"argument": "input_pretrained_algorithm_dir"})
+    index: PredictionIndex
+    output_argument = "output_embeddings_dir"
+    result_type = EmbeddingsArtifact
+
+
+@dataclass(frozen=True, kw_only=True)
+class TrainProbeRequest(StepRequest):
+    embeddings: EmbeddingsArtifact = field(metadata={"argument": "input_embeddings_dir"})
+    labels: TrainingLabels = field(metadata={"argument": "external_labels_dir"})
+    output_argument = "output_probe_algorithm_dir"
+    result_type = ProbeAlgorithmArtifact
+
+
+@dataclass(frozen=True, kw_only=True)
+class PredictSupervisedRequest(StepRequest):
+    data: PreparedDataArtifact = field(metadata={"argument": "input_data_dir"})
+    algorithm: SupervisedAlgorithmArtifact = field(metadata={"argument": "input_supervised_algorithm_dir"})
+    index: PredictionIndex
+    output_argument = "output_predictions_dir"
+    result_type = PredictionsArtifact
+
+
+@dataclass(frozen=True, kw_only=True)
+class PredictFinetuneRequest(StepRequest):
+    data: PreparedDataArtifact = field(metadata={"argument": "input_data_dir"})
+    algorithm: FinetunedAlgorithmArtifact = field(metadata={"argument": "input_finetuned_algorithm_dir"})
+    index: PredictionIndex
+    output_argument = "output_predictions_dir"
+    result_type = PredictionsArtifact
+
+
+@dataclass(frozen=True, kw_only=True)
+class PredictProbeRequest(StepRequest):
+    embeddings: EmbeddingsArtifact = field(metadata={"argument": "input_embeddings_dir"})
+    algorithm: ProbeAlgorithmArtifact = field(metadata={"argument": "input_probe_algorithm_dir"})
+    index: PredictionIndex
+    output_argument = "output_predictions_dir"
+    result_type = PredictionsArtifact
+
+
+@dataclass(frozen=True, kw_only=True)
+class PredictZeroShotDirectRequest(StepRequest):
+    data: PreparedDataArtifact = field(metadata={"argument": "input_data_dir"})
+    pretrained: PretrainedAlgorithmArtifact = field(metadata={"argument": "input_pretrained_algorithm_dir"})
+    index: PredictionIndex
+    task: TaskSpec
+    output_argument = "output_predictions_dir"
+    result_type = PredictionsArtifact
+
+
+@dataclass(frozen=True, kw_only=True)
+class InferTrajectoriesRequest(StepRequest):
+    data: PreparedDataArtifact = field(metadata={"argument": "input_data_dir"})
+    pretrained: PretrainedAlgorithmArtifact = field(metadata={"argument": "input_pretrained_algorithm_dir"})
+    index: PredictionIndex
+    output_argument = "output_trajectories_dir"
+    result_type = TrajectoriesArtifact
+
+
+@dataclass(frozen=True, kw_only=True)
+class PredictZeroShotMaterializedRequest(StepRequest):
+    data: PreparedDataArtifact = field(metadata={"argument": "input_data_dir"})
+    trajectories: TrajectoriesArtifact = field(metadata={"argument": "input_trajectories_dir"})
+    meds_dir: Path = field(metadata={"argument": "external_meds_dir"})
+    index: PredictionIndex
+    task: TaskSpec
+    output_argument = "output_predictions_dir"
+    result_type = PredictionsArtifact
+
+
+@dataclass(frozen=True, kw_only=True)
+class PredictOnlyRequest(StepRequest):
+    data: PreparedDataArtifact = field(metadata={"argument": "input_data_dir"})
+    index: PredictionIndex
+    context: PredictionContext | None = None
+    task: TaskSpec | None = None
+    output_argument = "output_predictions_dir"
+    result_type = PredictionsArtifact

meds_algorithm/runner.py

@@ -0,0 +1,232 @@
+"""The single public execution path for typed algorithms and their CLI adapters."""
+
+from __future__ import annotations
+
+from dataclasses import fields, is_dataclass, replace
+from pathlib import Path
+
+from .algorithms import Algorithm, profile_class, request_type
+from .artifacts.manifest import digest_config, digest_file, measured_artifact
+from .artifacts.references import ArtifactDestination, PayloadMetadata, PredictionsArtifact
+from .data.predicates import RESOLVED_PREDICATES_FILENAME, compose_feature_predicates
+from .requests import PredictionContext, PredictionIndex, PreprocessDataRequest, StepRequest
+from .tasks.spec import RelaxationLedger
+
+
+def _paths(value):
+    if isinstance(value, Path):
+        yield value
+    elif is_dataclass(value):
+        for field in fields(value):
+            yield from _paths(getattr(value, field.name))
+
+
+class StepRunner:
+    """A fresh algorithm instance is supplied per call; persisted artifacts carry fitted state."""
+
+    def __init__(self, *, repo: Path | None = None):
+        self.repo = None if repo is None else Path(repo).resolve()
+
+    def run(
+        self,
+        algorithm: Algorithm,
+        step: str,
+        request: StepRequest,
+        *,
+        profile: str,
+        evaluation_labels_dir: Path | None = None,
+    ):
+        expected = request_type(profile, step)
+        if not isinstance(algorithm, profile_class(profile)):
+            raise TypeError(f"Algorithm does not implement {profile}")
+        if type(request) is not expected:
+            raise TypeError(f"{step} requires {expected.__name__}")
+        # Reconstruct to enforce types/value invariants even for hand-built Python requests.
+        request = expected.from_dict(request.to_dict())
+        algorithm.config_type.from_dict(algorithm.config.to_dict())
+        destination = request.output.directory
+        input_paths = [
+            path
+            for field in fields(request)
+            if field.name != "output"
+            for path in _paths(getattr(request, field.name))
+        ]
+        additional = (
+            algorithm.config.additional_predicates_file
+            if isinstance(request, PreprocessDataRequest)
+            else None
+        )
+        if additional is not None:
+            input_paths.append(additional)
+        if evaluation_labels_dir is not None:
+            if request.result_type is not PredictionsArtifact:
+                raise ValueError("Evaluation labels are allowed only after prediction")
+            evaluation_labels_dir = Path(evaluation_labels_dir).resolve()
+            input_paths.append(evaluation_labels_dir)
+        for path in input_paths:
+            if not path.exists():
+                raise FileNotFoundError(path)
+            if destination == path or destination in path.parents or path in destination.parents:
+                raise ValueError("Output must not overlap any input path")
+        inputs = {}
+        resolved_predicates = None
+        if additional is not None:
+            resolved_predicates, provenance = compose_feature_predicates(request.predicates_file, additional)
+            inputs["feature_predicates"] = provenance
+            if provenance["base"] is not None:
+                inputs["external_predicates_file"] = provenance["base"]
+        for argument, artifact in request.artifact_inputs():
+            artifact.read_manifest()
+            inputs[argument] = {
+                "path": str(artifact.directory),
+                "manifest_digest": digest_file(artifact.directory / "manifest.yaml"),
+            }
+        index = getattr(request, "index", None)
+        if isinstance(index, PredictionIndex):
+            keys = index.read()
+            inputs["external_index_dir"] = {
+                "path": str(index.directory),
+                "splits": list(index.splits),
+                "keys_digest": digest_config(keys.sort(["subject_id", "prediction_time"]).write_json()),
+            }
+        context = getattr(request, "context", None)
+        if isinstance(context, PredictionContext):
+            context.read(index)  # Disjoint keys and permitted split names, before algorithm code.
+        task = getattr(request, "task", None)
+        if task is not None:
+            if task.predicates_file != request.predicates_file:
+                raise ValueError("Task predicates and request predicates must agree")
+            inputs["task"] = task.provenance()
+        if resolved_predicates is None:
+            algorithm.validate_inputs(request)
+        metadata = None
+        details = {
+            "algorithm": {
+                "name": algorithm.name,
+                "implementation": f"{type(algorithm).__module__}.{type(algorithm).__qualname__}",
+                "config_type": f"{type(algorithm.config).__module__}.{type(algorithm.config).__qualname__}",
+                "config_schema_version": algorithm.config.schema_version,
+                "config": algorithm.config.to_dict(),
+            },
+            "invocation": {
+                "profile": profile,
+                "request": request.to_dict(),
+                "evaluation_labels_dir": None
+                if evaluation_labels_dir is None
+                else str(evaluation_labels_dir),
+            },
+        }
+        with measured_artifact(
+            destination,
+            artifact_type=request.result_type.kind.value,
+            command=step,
+            producer=f"{type(algorithm).__module__}.{type(algorithm).__qualname__}.{step}",
+            payload_format=lambda: f"{metadata.format}/v{metadata.version}",
+            inputs=inputs,
+            config_digest=digest_config(
+                {
+                    "config": algorithm.config.to_dict(),
+                    "request": request.to_dict(),
+                    "feature_predicates": inputs.get("feature_predicates"),
+                }
+            ),
+            semantics_digest=None if task is None else task.semantics_digest(),
+            external_predicates_file=request.predicates_file if resolved_predicates is None else None,
+            overwrite=request.execution.overwrite,
+            repo=self.repo,
+            manifest_fields=details,
+        ) as staging:
+            working = replace(request, output=ArtifactDestination(staging))
+            if resolved_predicates is not None:
+                effective_path = staging / RESOLVED_PREDICATES_FILENAME
+                effective_path.write_bytes(resolved_predicates)
+                working = replace(working, predicates_file=effective_path)
+                algorithm.validate_inputs(working)
+            metadata = getattr(algorithm, step)(working)
+            if resolved_predicates is not None and (
+                not effective_path.is_file() or effective_path.read_bytes() != resolved_predicates
+            ):
+                raise ValueError("Algorithm modified the runner-owned resolved feature predicates")
+            if algorithm.config.to_dict() != details["algorithm"]["config"]:
+                raise ValueError("Algorithm configuration changed during execution")
+            if not isinstance(metadata, PayloadMetadata):
+                raise TypeError("Algorithm methods must return PayloadMetadata")
+            if (staging / "manifest.yaml").exists():
+                raise ValueError("Only the runner may write manifest.yaml")
+            if request.result_type is PredictionsArtifact:
+                self._validate_predictions(staging, index, evaluation_labels_dir)
+                if profile.startswith("zero_shot_"):
+                    RelaxationLedger.read(staging)
+            for reserved in ("config.json", "request.json"):
+                if (staging / reserved).exists():
+                    raise ValueError(f"{reserved} is reserved for runner provenance")
+            algorithm.config.save(staging / "config.json")
+            request.save(staging / "request.json")
+        return request.result_type.open(destination)
+
+    @staticmethod
+    def _validate_predictions(staging, index, evaluation_labels_dir):
+        import polars as pl
+
+        from .evaluation.predictions import attach_ground_truth, check_decoded
+
+        paths = sorted(staging.rglob("*.parquet"))
+        if not paths:
+            raise ValueError("Predictions must contain Parquet shards")
+        frames = [pl.read_parquet(path) for path in paths]
+        if any("boolean_value" in frame.columns for frame in frames):
+            raise ValueError(
+                "Algorithm predictions must not contain ground truth; runner attaches it after scoring"
+            )
+        check_decoded(index.read(), pl.concat(frames))
+        if evaluation_labels_dir is not None:
+            for path, frame in zip(paths, frames, strict=True):
+                attach_ground_truth(frame, evaluation_labels_dir, index.splits).write_parquet(path)
+
+
+class AlgorithmRepository:
+    """Only a profile-to-implementation association; signatures and order live on the ABCs."""
+
+    def __init__(self, implementations: dict[str, type[Algorithm]], *, repo: Path | None = None):
+        if not implementations:
+            raise ValueError("At least one profile implementation is required")
+        for profile, implementation in implementations.items():
+            if not isinstance(implementation, type) or not issubclass(implementation, profile_class(profile)):
+                raise TypeError(f"Implementation must inherit {profile_class(profile).__name__}")
+            if implementation.__abstractmethods__:
+                raise TypeError(
+                    f"Unimplemented abstract methods: {sorted(implementation.__abstractmethods__)}"
+                )
+        self.implementations = dict(implementations)
+        self.profiles = tuple(implementations)
+        self.runner = StepRunner(repo=repo)
+
+    def select_profile(self, profile=None):
+        if profile is None:
+            if len(self.profiles) != 1:
+                raise ValueError("Several profiles are declared; select one with --profile")
+            return self.profiles[0]
+        if profile not in self.implementations:
+            raise ValueError(f"Profile {profile!r} is not declared")
+        return profile
+
+    def profile_commands(self, profile=None):
+        return profile_class(self.select_profile(profile)).steps
+
+    def run(self, step: str, arguments: dict, *, profile=None):
+        profile = self.select_profile(profile)
+        request_cls = request_type(profile, step)
+        arguments = dict(arguments)
+        implementation = self.implementations[profile]
+        config_file = arguments.pop("config_file", None)
+        config = (
+            implementation.config_type.from_file(config_file) if config_file else implementation.config_type()
+        )
+        evaluation = arguments.pop("external_evaluation_labels_dir", None)
+        return self.runner.run(
+            implementation(config),
+            step,
+            request_cls.from_arguments(arguments),
+            profile=profile,
+            evaluation_labels_dir=evaluation,
+        )

meds_algorithm/runtime/__init__.py

@@ -0,0 +1 @@
+"""Optional-platform resource sampling, explicit algorithm provenance and subprocess execution."""

meds_algorithm/runtime/process.py

@@ -0,0 +1,50 @@
+import os
+import signal
+import subprocess
+from contextlib import suppress
+
+RUN_TIMEOUT = 5400
+
+
+def run(cmd, *, timeout=RUN_TIMEOUT, env=None):
+    """Run in an owned process group and stop its descendants if interrupted or timed out.
+
+    Descendants must remain in the group; deliberately detached services are not supported.
+    Windows uses taskkill /T to terminate the child tree while the parent is still alive.
+    """
+    process = subprocess.Popen(
+        [str(value) for value in cmd],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        start_new_session=os.name == "posix",
+        env=None if env is None else {**os.environ, **env},
+    )
+    try:
+        stdout, stderr = process.communicate(timeout=timeout)
+    except BaseException:
+        try:
+            if os.name == "posix":
+                with suppress(ProcessLookupError):
+                    os.killpg(process.pid, signal.SIGKILL)
+            else:
+                subprocess.run(
+                    ["taskkill", "/PID", str(process.pid), "/T", "/F"],
+                    check=True,
+                    capture_output=True,
+                    timeout=30,
+                )
+        finally:
+            if process.poll() is None:
+                process.kill()
+            process.wait()
+            process.stdout.close()
+            process.stderr.close()
+        raise
+    result = subprocess.CompletedProcess(process.args, process.returncode, stdout, stderr)
+    if result.returncode:
+        raise AssertionError(
+            f"command failed ({result.returncode}): {' '.join(map(str, cmd))}\n"
+            f"--- stdout ---\n{result.stdout}\n--- stderr ---\n{result.stderr}"
+        )
+    return result

meds_algorithm/runtime/provenance.py

@@ -0,0 +1,31 @@
+"""Record the caller's algorithm checkout; never infer it from the core package or cwd."""
+
+import subprocess
+from pathlib import Path
+from typing import Any
+
+
+def code_provenance(repo: Path | str | None) -> dict[str, Any]:
+    unknown = {
+        "repository": None if repo is None else str(Path(repo).resolve()),
+        "git_commit": None,
+        "dirty": None,
+    }
+    if repo is None:
+        return unknown
+    root = Path(repo).resolve()
+    # Do not accidentally attribute an unpacked wheel to an enclosing unrelated checkout.
+    if not (root / ".git").exists():
+        return unknown
+
+    def git(*args):
+        return subprocess.run(
+            ["git", "-C", str(root), *args], check=True, capture_output=True, text=True
+        ).stdout.strip()
+
+    try:
+        commit = git("rev-parse", "HEAD")
+        status = git("status", "--porcelain")
+    except (OSError, subprocess.CalledProcessError):
+        return unknown
+    return {"repository": str(root), "git_commit": commit, "dirty": bool(status)}

meds_algorithm/runtime/resources.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import os
+import sys
+import threading
+from pathlib import Path
+
+try:
+    import resource
+except ImportError:
+    resource = None
+
+
+def _rss_bytes(value: int) -> int:
+    # Linux reports KiB; macOS reports bytes. sys.platform is deliberately avoided so unusual Unix
+    # implementations can override/report their method rather than receiving a false portable claim.
+    return value * 1024 if sys.platform != "darwin" else value
+
+
+class _ProcessTreeMemorySampler:
+    """Sample aggregate PSS/RSS for this process and its live descendants on Linux."""
+
+    def __init__(self, interval_seconds: float = 0.25) -> None:
+        self.interval_seconds = interval_seconds
+        self.peak_pss_bytes: int | None = None
+        self.peak_rss_bytes: int | None = None
+        self.source = "linux_proc_smaps_rollup" if Path("/proc/self/smaps_rollup").is_file() else "getrusage"
+        self.includes_descendants = self.source == "linux_proc_smaps_rollup"
+        self._stop = threading.Event()
+        self._thread = threading.Thread(target=self._run, name="meds-memory-sampler", daemon=True)
+
+    def start(self) -> None:
+        self._sample()
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._sample()
+        self._stop.set()
+        self._thread.join(timeout=max(1.0, self.interval_seconds * 4))
+        self._sample()
+        if self.peak_rss_bytes is None:
+            self.includes_descendants = False
+            if resource is not None:
+                self.source = "getrusage"
+                usage = resource.getrusage(resource.RUSAGE_SELF)
+                self.peak_rss_bytes = _rss_bytes(usage.ru_maxrss)
+            else:
+                self.source = "unavailable"
+
+    def _run(self) -> None:
+        while not self._stop.wait(self.interval_seconds):
+            self._sample()
+
+    @staticmethod
+    def _process_tree(root_pid: int) -> set[int]:
+        found: set[int] = set()
+        pending = [root_pid]
+        while pending:
+            pid = pending.pop()
+            if pid in found:
+                continue
+            found.add(pid)
+            try:
+                tasks = list(Path(f"/proc/{pid}/task").iterdir())
+            except OSError:
+                continue
+            for task in tasks:
+                try:
+                    pending.extend(int(value) for value in (task / "children").read_text().split())
+                except (OSError, ValueError):
+                    continue
+        return found
+
+    @staticmethod
+    def _smaps(pid: int) -> tuple[int, int] | None:
+        try:
+            values = {}
+            for line in Path(f"/proc/{pid}/smaps_rollup").read_text().splitlines():
+                key, separator, rest = line.partition(":")
+                if separator and key in {"Pss", "Rss"}:
+                    values[key] = int(rest.split()[0]) * 1024
+            return values["Pss"], values["Rss"]
+        except (FileNotFoundError, KeyError, PermissionError, ProcessLookupError, ValueError):
+            return None
+
+    def _sample(self) -> None:
+        if self.source != "linux_proc_smaps_rollup":
+            return
+        samples = [sample for pid in self._process_tree(os.getpid()) if (sample := self._smaps(pid))]
+        if not samples:
+            return
+        if len(samples) != len(self._process_tree(os.getpid())):
+            self.includes_descendants = False
+        pss = sum(sample[0] for sample in samples)
+        rss = sum(sample[1] for sample in samples)
+        self.peak_pss_bytes = max(self.peak_pss_bytes or 0, pss)
+        self.peak_rss_bytes = max(self.peak_rss_bytes or 0, rss)