cortexgrid 0.2.85__py3-none-any.whl

cortexgrid/experiment.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+
+from cortexgrid import s3_util
+from cortexgrid.infra import get_mlflow_tracking_uri
+from cortexgrid.jobs import stop_experiment_run_jobs
+from cortexgrid.ray_util import list_ray_jobs_with_submission_id, stop_ray_job
+from cortexgrid.model_storage import delete_models_for_run
+from haikunator import Haikunator  # type: ignore
+from mlflow.tracking import MlflowClient
+
+
+log = logging.getLogger(__name__)
+_SINGLETON_EXPERIMENT: Experiment | None = None
+
+
+@dataclass
+class Experiment:
+    experiment_name: str
+    run_id: str
+
+    def run_name(self) -> str:
+        client = MlflowClient(tracking_uri=get_mlflow_tracking_uri())
+        return client.get_run(self.run_id).info.run_name or self.run_id
+
+    @classmethod
+    def init(cls, name: str | None = None) -> "Experiment":
+        """Create a new MLflow experiment+run. Once per process."""
+        logging.basicConfig(
+            level=logging.INFO,
+            format="%(asctime)s.%(msecs)03d %(levelname)s %(name)s: %(message)s",
+            datefmt="%H:%M:%S",
+        )
+
+        if _SINGLETON_EXPERIMENT is not None:
+            if name is not None and _SINGLETON_EXPERIMENT.experiment_name != name:
+                raise ValueError(
+                    f"Active experiment has a different name {name} != "
+                    f"{_SINGLETON_EXPERIMENT.experiment_name}"
+                )
+            return _SINGLETON_EXPERIMENT
+
+        experiment_name, run_id = _try_create_experiment_and_run(
+            experiment=name,
+            mlflow_tracking_uri=get_mlflow_tracking_uri(),
+        )
+        instance = cls(
+            experiment_name=experiment_name,
+            run_id=run_id,
+        )
+        set_instance(instance)
+        return instance
+
+    @classmethod
+    def from_experiment(cls, experiment_name: str, run_id: str) -> "Experiment":
+        """Bind to an existing MLflow experiment+run. Once per process."""
+        logging.basicConfig(
+            level=logging.INFO,
+            format="%(asctime)s.%(msecs)03d %(levelname)s %(name)s: %(message)s",
+            datefmt="%H:%M:%S",
+        )
+
+        if _SINGLETON_EXPERIMENT is not None:
+            if (
+                _SINGLETON_EXPERIMENT.experiment_name != experiment_name
+                or _SINGLETON_EXPERIMENT.run_id != run_id
+            ):
+                raise ValueError(
+                    f"Active experiment is different to the requested one: "
+                    f"({experiment_name}, {run_id}) != "
+                    f"({_SINGLETON_EXPERIMENT.experiment_name}, {_SINGLETON_EXPERIMENT.run_id})"
+                )
+            return _SINGLETON_EXPERIMENT
+
+        instance = cls(
+            experiment_name=experiment_name,
+            run_id=run_id,
+        )
+        set_instance(instance)
+        return instance
+
+    def get_jobs(self) -> list[str]:
+        """Return cortexgrid job IDs submitted against this experiment+run."""
+        client = MlflowClient(tracking_uri=get_mlflow_tracking_uri())
+        return [
+            Path(f.path).name
+            for f in client.list_artifacts(self.run_id, path="job")
+            if f.is_dir
+        ]
+
+    @classmethod
+    def get_instance(cls) -> "Experiment":
+        if _SINGLETON_EXPERIMENT is None:
+            raise ValueError("Call Experiment.init or Experiment.from_experiment first")
+        return _SINGLETON_EXPERIMENT
+
+    @classmethod
+    def close(cls) -> None:
+        """Detach the active experiment so a different one can be init'd in this process."""
+        set_instance(None)
+
+
+def set_instance(instance: Experiment | None) -> None:
+    global _SINGLETON_EXPERIMENT
+    _SINGLETON_EXPERIMENT = instance
+
+
+def clear_instance() -> None:
+    # Use only in tests to clean between tests
+    global _SINGLETON_EXPERIMENT
+    _SINGLETON_EXPERIMENT = None
+
+
+def _try_create_experiment_and_run(
+    experiment: str | None, mlflow_tracking_uri: str
+) -> tuple[str, str]:
+    name_gen = Haikunator()
+    if experiment is None:
+        experiment = name_gen.haikunate(token_length=2, token_chars="0123456789")
+
+    client = MlflowClient(tracking_uri=mlflow_tracking_uri)
+    experiment_obj = client.get_experiment_by_name(name=experiment)
+    if experiment_obj:
+        experiment_id = experiment_obj.experiment_id
+    else:
+        experiment_id = client.create_experiment(name=experiment)
+
+    run_name = name_gen.haikunate(token_length=2, token_chars="0123456789")
+    run = client.create_run(experiment_id=experiment_id, run_name=run_name)
+
+    return (experiment, run.info.run_id)
+
+
+def delete_run(run_id: str) -> None:
+    """Soft-delete a run in MLflow, cancel its Ray attempts, and wipe its
+    S3 job packages so it cannot be relaunched or re-read.
+
+    stop_experiment_run_jobs runs first so the control plane stops spawning
+    fresh Ray attempts for retry=True jobs before we tear the run down."""
+    log.info("delete_run(%s): start", run_id)
+    stop_experiment_run_jobs(run_id)
+    log.info("delete_run(%s): stop_experiment_run_jobs done", run_id)
+    client = MlflowClient(tracking_uri=get_mlflow_tracking_uri())
+    job_ids = [
+        Path(f.path).name for f in client.list_artifacts(run_id, path="job") if f.is_dir
+    ]
+    log.info("delete_run(%s): %d job artifact(s) to clean", run_id, len(job_ids))
+    all_submissions = list_ray_jobs_with_submission_id()
+    for job_id in job_ids:
+        prefix = f"{run_id}-{job_id}-"
+        for sid in all_submissions:
+            if sid.startswith(prefix):
+                stop_ray_job(sid)
+        s3_util.delete_prefix(f"job/{job_id}/")
+    delete_models_for_run(run_id)
+    client.delete_run(run_id)
+    log.info("delete_run(%s): done", run_id)
+
+
+def list_run_ids_in_experiment(name: str) -> list[str]:
+    """Return the run IDs of every active run in the named experiment."""
+    client = MlflowClient(tracking_uri=get_mlflow_tracking_uri())
+    exp = client.get_experiment_by_name(name)
+    if exp is None:
+        return []
+    return [
+        r.info.run_id for r in client.search_runs(experiment_ids=[exp.experiment_id])
+    ]
+
+
+def delete_experiment(name: str) -> None:
+    """Soft-delete every run in the experiment, then the experiment itself.
+
+    Idempotent: already-deleted experiments are treated as success."""
+    log.info("delete_experiment(%r): start", name)
+    client = MlflowClient(tracking_uri=get_mlflow_tracking_uri())
+    exp = client.get_experiment_by_name(name)
+    if exp is None:
+        log.info("delete_experiment(%r): early-exit, experiment not found", name)
+        return
+    if exp.lifecycle_stage != "active":
+        log.info(
+            "delete_experiment(%r): early-exit, lifecycle=%s", name, exp.lifecycle_stage
+        )
+        return
+    runs = list(client.search_runs(experiment_ids=[exp.experiment_id]))
+    log.info("delete_experiment(%r): %d active run(s) to delete", name, len(runs))
+    for run in runs:
+        delete_run(run.info.run_id)
+    client.delete_experiment(exp.experiment_id)
+    log.info("delete_experiment(%r): done", name)
+
+
+def list_experiments() -> list[Experiment]:
+    """Map MLflow experiment names to their run IDs."""
+    client = MlflowClient(tracking_uri=get_mlflow_tracking_uri())
+    result: list[Experiment] = []
+    for exp in client.search_experiments():
+        runs = client.search_runs(experiment_ids=[exp.experiment_id])
+        for run in runs:
+            result.append(Experiment(exp.name, run_id=run.info.run_id))
+    return result
+
+
+def get_experiment_by_run_name(run_name: str) -> Experiment:
+    """Resolve a run by its haikunator name back to its (experiment_name, run_id) pair."""
+    client = MlflowClient(tracking_uri=get_mlflow_tracking_uri())
+    experiment_ids = [e.experiment_id for e in client.search_experiments()]
+    if not experiment_ids:
+        raise ValueError(f"No run named {run_name!r}")
+    runs = client.search_runs(
+        experiment_ids=experiment_ids,
+        filter_string=f"attributes.run_name = '{run_name}'",
+        max_results=1,
+    )
+    if not runs:
+        raise ValueError(f"No run named {run_name!r}")
+    run = runs[0]
+    exp = client.get_experiment(run.info.experiment_id)
+    return Experiment(experiment_name=exp.name, run_id=run.info.run_id)

cortexgrid/infra.py

@@ -0,0 +1,39 @@
+from cortexgrid.secrets import get_secret
+from mlflow.tracking import MlflowClient
+
+
+def get_mlflow_tracking_uri() -> str:
+    return get_secret("MLFLOW_TRACKING_URI")
+
+
+def get_ray_job_server_uri() -> str:
+    return get_secret("RAY_JOB_SERVER_URI")
+
+
+def get_ray_serve_uri() -> str:
+    """HTTP base URL where Ray Serve apps are reachable (data plane, port 8000)."""
+    return get_secret("RAY_SERVE_URI")
+
+
+def get_ray_serve_applications_uri() -> str:
+    """Dashboard REST endpoint for declarative Serve app management."""
+    return f"{get_ray_job_server_uri()}/api/serve/applications/"
+
+
+def get_s3_endpoint_url() -> str:
+    # AWS profile: regional s3.amazonaws.com URL (stored as "" = no override).
+    # On-prem: tailnet-reachable MinIO NodePort URL.
+    return get_secret("S3_ENDPOINT_URL")
+
+
+def get_s3_bucket() -> str:
+    # Provisioned by terraform/platform/s3 on AWS; created lazily on first
+    # upload against on-prem MinIO.
+    return get_secret("S3_BUCKET_NAME")
+
+
+def get_mlflow_run_url(run_id: str) -> str:
+    base = get_mlflow_tracking_uri()
+    client = MlflowClient(tracking_uri=base)
+    run = client.get_run(run_id)
+    return f"{base}/#/experiments/{run.info.experiment_id}/runs/{run_id}"

cortexgrid/jobs.py

@@ -0,0 +1,292 @@
+"""Submit tasks to the cortexgrid control plane."""
+
+from __future__ import annotations
+
+import cloudpickle  # type: ignore
+from dataclasses import asdict, dataclass, field
+import inspect
+import io
+import json
+import logging
+from pathlib import Path
+import sys
+import tarfile
+import tempfile
+from typing import Any, Callable
+
+from cortexgrid import s3_util
+from cortexgrid._bundle import bundle, stage, worker_provides
+from cortexgrid.infra import get_mlflow_tracking_uri
+from cortexgrid.ray_util import get_ray_job_id_for_cortexgrid_job
+from haikunator import Haikunator  # type: ignore
+from mlflow.tracking import MlflowClient
+from pydantic import BaseModel, ConfigDict
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class LifecycleEvent:
+    """A single observed state on a given attempt of a job.
+
+    ``start`` and ``end`` are ISO 8601 timestamps. ``end`` is ``None``
+    while the state is still current; it is set when a subsequent
+    observation shows the (attempt, state) pair has changed.
+    ``ray_job_id`` is the Ray submission id observed at record time and
+    is ``None`` for the pre-submission PENDING entry of a given attempt.
+    ``error`` carries a worker-submission exception message and is
+    attached to the event that was current when the worker failed.
+    """
+
+    attempt: int
+    state: str
+    start: str
+    end: str | None = None
+    ray_job_id: str | None = None
+    error: str | None = None
+
+
+@dataclass
+class JobLifecycle:
+    """Static identity and latches for a job.
+
+    JobLifecycle is the source of truth for *job identity* and for a
+    handful of fields that are either immutable or can only change once
+    over the lifetime of a job. Live execution status is never stored
+    here — it is derived on demand from Ray by :func:`get_ray_job_status`.
+    """
+
+    experiment_name: str
+    run_id: str
+    job_id: str
+    stop_requested: bool = False  # latch: False -> True, never cleared
+    retry: bool = False  # static flag set at job creation
+    num_gpus: int = 0
+    num_cpus: int = 1
+    history: list[LifecycleEvent] = field(default_factory=list)
+
+    def to_json(self) -> str:
+        return json.dumps(asdict(self))
+
+    @classmethod
+    def from_json(cls, text: str) -> "JobLifecycle":
+        data = json.loads(text)
+        data.pop("error", None)
+        data["history"] = [LifecycleEvent(**e) for e in data.get("history", [])]
+        return cls(**data)
+
+    def get_ray_job_id(
+        self, all_ray_submission_ids: list[str] | None = None
+    ) -> str | None:
+        return get_ray_job_id_for_cortexgrid_job(
+            self.run_id, self.job_id, all_ray_submission_ids
+        )
+
+    def download_project_code_root(self) -> str:
+        client = MlflowClient(tracking_uri=get_mlflow_tracking_uri())
+        manifest_rel = f"job/{self.job_id}/manifest.json"
+        if not any(
+            a.path == manifest_rel
+            for a in client.list_artifacts(self.run_id, f"job/{self.job_id}")
+        ):
+            raise FileNotFoundError(
+                f"artifact {manifest_rel} not found in run {self.run_id}"
+            )
+        manifest_path = client.download_artifacts(self.run_id, manifest_rel)
+        manifest = json.loads(Path(manifest_path).read_text())
+        _, _, src_path = (
+            manifest["code_tarball_uri"].removeprefix("s3://").partition("/")
+        )
+        extract_dir = Path(tempfile.mkdtemp())
+        tarball_local = s3_util.download(
+            src_path, local_path=str(extract_dir / "project_code_root.tar.gz")
+        )
+        with tarfile.open(tarball_local, "r:gz") as tar:
+            tar.extractall(extract_dir)
+        return str(extract_dir / "project_code_root")
+
+    def save_to_mlflow(self) -> None:
+        artifact_path = f"job/{self.job_id}"
+        client = MlflowClient(tracking_uri=get_mlflow_tracking_uri())
+        log.info(
+            "Saving lifecycle for job %s (stop_requested=%s)",
+            self.job_id,
+            self.stop_requested,
+        )
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            local_path = Path(tmp_dir, "lifecycle.json")
+            local_path.write_text(self.to_json())
+            client.log_artifact(
+                self.run_id, str(local_path), artifact_path=artifact_path
+            )
+
+    @classmethod
+    def load_from_mlflow(cls, run_id: str, job_id: str) -> "JobLifecycle":
+        client = MlflowClient(tracking_uri=get_mlflow_tracking_uri())
+        lifecycle_rel = f"job/{job_id}/lifecycle.json"
+        if not any(
+            a.path == lifecycle_rel
+            for a in client.list_artifacts(run_id, f"job/{job_id}")
+        ):
+            raise FileNotFoundError(
+                f"artifact {lifecycle_rel} not found in run {run_id}"
+            )
+        local_path = client.download_artifacts(run_id, lifecycle_rel)
+        return cls.from_json(Path(local_path).read_text())
+
+
+class Payload(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    experiment_name: str
+    run_id: str
+    job_id: str
+    fn: Callable[..., Any]
+    args: tuple[Any, ...]
+    kwargs: dict[str, Any]
+    project_code_root: str
+    num_gpus: int = 0
+    num_cpus: int = 1
+
+    def save_to_mlflow(self) -> None:
+        artifact_path = f"job/{self.job_id}"
+        client = MlflowClient(tracking_uri=get_mlflow_tracking_uri())
+        log.info(
+            "Uploading payload for job %s from %s", self.job_id, self.project_code_root
+        )
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            tarball_path = Path(tmp_dir, "project_code_root.tar.gz")
+            payload_bytes = cloudpickle.dumps(self)
+            with tarfile.open(tarball_path, "w:gz") as tar:
+                tar.add(self.project_code_root, arcname="project_code_root")
+                info = tarfile.TarInfo("project_code_root/payload.pkl")
+                info.size = len(payload_bytes)
+                tar.addfile(info, io.BytesIO(payload_bytes))
+            tarball_uri = s3_util.upload(
+                str(tarball_path),
+                dest_path=f"{artifact_path}/project_code_root.tar.gz",
+            )
+            manifest_path = Path(tmp_dir, "manifest.json")
+            manifest_path.write_text(json.dumps({"code_tarball_uri": tarball_uri}))
+            client.log_artifact(
+                self.run_id, str(manifest_path), artifact_path=artifact_path
+            )
+            log.info("Payload upload complete for job %s", self.job_id)
+
+    @classmethod
+    def load_from_mlflow(cls, run_id: str, job_id: str) -> "Payload":
+        client = MlflowClient(tracking_uri=get_mlflow_tracking_uri())
+        log.info("Downloading payload for job %s", job_id)
+        manifest_rel = f"job/{job_id}/manifest.json"
+        if not any(
+            a.path == manifest_rel
+            for a in client.list_artifacts(run_id, f"job/{job_id}")
+        ):
+            raise FileNotFoundError(
+                f"artifact {manifest_rel} not found in run {run_id}"
+            )
+        manifest_path = client.download_artifacts(run_id, manifest_rel)
+        manifest = json.loads(Path(manifest_path).read_text())
+        _, _, src_path = (
+            manifest["code_tarball_uri"].removeprefix("s3://").partition("/")
+        )
+        extract_dir = Path(tempfile.mkdtemp())
+        tarball_local = s3_util.download(
+            src_path, local_path=str(extract_dir / "project_code_root.tar.gz")
+        )
+        with tarfile.open(tarball_local, "r:gz") as tar:
+            tar.extractall(extract_dir)
+        project_code_root = str(extract_dir / "project_code_root")
+        sys.path.insert(0, project_code_root)
+        try:
+            payload = cloudpickle.loads(
+                Path(project_code_root, "payload.pkl").read_bytes()
+            )
+        finally:
+            sys.path.remove(project_code_root)
+        payload.project_code_root = project_code_root
+        log.info(
+            "Payload downloaded for job %s, project_code_root=%s",
+            job_id,
+            payload.project_code_root,
+        )
+
+        return payload
+
+
+def schedule_remote_job(
+    experiment_name: str,
+    run_id: str,
+    fn: Callable[..., Any],
+    *args: Any,
+    num_gpus: int = 0,
+    num_cpus: int = 1,
+    retry: bool = False,
+    **kwargs: Any,
+) -> str:
+    """Submit a function to the control plane. Returns a job ID."""
+    job_id = Haikunator().haikunate(token_length=2, token_chars="0123456789")
+    entry_file = Path(inspect.getfile(fn)).resolve()
+    driver_file = Path(__file__).with_name("_ray_job_driver.py")
+    files = bundle(entry_file).merge(bundle(driver_file)).local_files - worker_provides()
+    with tempfile.TemporaryDirectory() as tmp:
+        code_root = Path(tmp, "project_code_root")
+        stage(files, code_root)
+        log.info("Submitting job %s (%d files)", job_id, len(files))
+        Payload(
+            experiment_name=experiment_name,
+            run_id=run_id,
+            job_id=job_id,
+            fn=fn,
+            args=args,
+            kwargs=kwargs,
+            project_code_root=str(code_root),
+            num_gpus=num_gpus,
+            num_cpus=num_cpus,
+        ).save_to_mlflow()
+        JobLifecycle(
+            experiment_name=experiment_name,
+            run_id=run_id,
+            job_id=job_id,
+            retry=retry,
+            num_gpus=num_gpus,
+            num_cpus=num_cpus,
+        ).save_to_mlflow()
+    return job_id
+
+
+def list_experiment_run_jobs(run_id: str) -> list[JobLifecycle]:
+    """Return all jobs and their lifecycle states for this experiment+run."""
+    client = MlflowClient(tracking_uri=get_mlflow_tracking_uri())
+    entries = client.list_artifacts(run_id, path="job")
+    result: list[JobLifecycle] = []
+    for entry in entries:
+        if not entry.is_dir:
+            continue
+        job_id = Path(entry.path).name
+        try:
+            result.append(JobLifecycle.load_from_mlflow(run_id, job_id))
+        except Exception:
+            logging.getLogger(__name__).warning(
+                "Skipping job %s: missing lifecycle", job_id
+            )
+    return result
+
+
+def stop_experiment_run_jobs(run_id: str) -> None:
+    """Request all jobs in the run to stop by flipping the stop_requested latch.
+
+    This function never touches Ray. The control plane observes the
+    latch on its next poll and calls `ray.stop_job` for any job that
+    has reached Ray. For jobs that have not yet been submitted, the
+    latch short-circuits the submission path in the worker.
+
+    Idempotent: already-requested jobs are skipped, and the flag has
+    no effect on jobs that Ray already reports as terminal.
+    """
+    for job in list_experiment_run_jobs(run_id):
+        if job.stop_requested:
+            continue
+        job.stop_requested = True
+        job.save_to_mlflow()

cortexgrid/mlflow_util.py

@@ -0,0 +1,110 @@
+"""MLflow wrappers.
+
+Thin layer that configures MLflow tracking URI and S3 credentials,
+then exposes convenience functions for common operations.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+import requests
+
+from cortexgrid.experiment import Experiment
+from cortexgrid.infra import get_mlflow_tracking_uri
+from mlflow.entities import Metric
+from mlflow.tracking import MlflowClient
+
+
+def log_metric(key: str, value: float, step: int | None = None) -> None:
+    """Log a metric to the current active MLflow run."""
+    experiment = Experiment.get_instance()
+
+    client = get_mlflow_client()
+    client.log_metric(experiment.run_id, key, value, step=step)
+
+
+def log_metrics(metrics: dict[str, float], step: int | None = None) -> None:
+    """Log multiple metrics to the current active MLflow run."""
+    experiment = Experiment.get_instance()
+
+    client = get_mlflow_client()
+    timestamp = int(time.time() * 1000)
+    metric_entities = [
+        Metric(key=k, value=v, timestamp=timestamp, step=step or 0)
+        for k, v in metrics.items()
+    ]
+    client.log_batch(experiment.run_id, metrics=metric_entities)
+
+
+def log_params(params: dict[str, Any]) -> None:
+    """Log parameters to the current active MLflow run."""
+    experiment = Experiment.get_instance()
+
+    client = get_mlflow_client()
+    for key, value in params.items():
+        client.log_param(experiment.run_id, key, value)
+
+
+def log_artifact(local_path: str, artifact_path: str | None = None) -> None:
+    """Log a file as an artifact to the current active MLflow run."""
+    experiment = Experiment.get_instance()
+
+    client = get_mlflow_client()
+    client.log_artifact(experiment.run_id, local_path, artifact_path=artifact_path)
+
+
+def get_mlflow_client() -> MlflowClient:
+    """Return a configured MlflowClient."""
+    return MlflowClient(tracking_uri=get_mlflow_tracking_uri())
+
+
+def list_run_metrics(run_id: str) -> list[str]:
+    """Return the metric key names logged for a run."""
+    client = get_mlflow_client()
+    run = client.get_run(run_id)
+    return list(run.data.metrics.keys())
+
+
+def get_metric_history(
+    run_id: str, key: str, max_points: int | None = None
+) -> list[dict[str, Any]]:
+    """Return the history of a metric as [{step, value, timestamp}, ...].
+
+    When `max_points` is given, MLflow samples server-side and returns at
+    most that many points (saves DB work and bytes-on-the-wire). Without
+    `max_points`, the full history is returned.
+    """
+    if max_points is not None:
+        url = (
+            f"{get_mlflow_tracking_uri().rstrip('/')}"
+            "/ajax-api/2.0/mlflow/metrics/get-history-bulk-interval"
+        )
+        response = requests.get(
+            url,
+            params={"run_ids": run_id, "metric_key": key, "max_results": max_points},
+        )
+        response.raise_for_status()
+        return [
+            {"step": int(m["step"]), "value": float(m["value"]), "timestamp": int(m["timestamp"])}
+            for m in response.json().get("metrics", [])
+        ]
+    client = get_mlflow_client()
+    history = client.get_metric_history(run_id, key)
+    return [
+        {"step": m.step, "value": m.value, "timestamp": m.timestamp} for m in history
+    ]
+
+
+def list_run_params(run_id: str) -> dict[str, str]:
+    """Return all parameter key/value pairs for a run."""
+    client = get_mlflow_client()
+    run = client.get_run(run_id)
+    return dict(run.data.params)
+
+
+def list_run_artifacts(run_id: str, path: str = "") -> list[str]:
+    """Return artifact paths for a run."""
+    client = get_mlflow_client()
+    return [a.path for a in client.list_artifacts(run_id, path=path)]