mllogs 0.2.0__tar.gz → 0.3.0__tar.gz

{mllogs-0.2.0 → mllogs-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mllogs
-Version: 0.2.0
+Version: 0.3.0
 Summary: Local experiment logging for machine learning
 Author: Finn Walsh
 License-Expression: MIT
@@ -45,15 +45,15 @@ client.list_runs()
 Retrieve or delete a saved run:
 
 ```python
-client.get_run(id)
-client.delete_run(id)
+client.get_run(run.id)
+client.delete_run(run.id)
 ```
 
 ## Features
 
 - Start and end experiment runs
 - Log parameters, metrics, and tags
-- Automatically persist completed runs to local storage
+- Persist completed runs to a local SQLite database
 - Load, list, and delete saved runs
 
 ## Development

{mllogs-0.2.0 → mllogs-0.3.0}/README.md

@@ -32,15 +32,15 @@ client.list_runs()
 Retrieve or delete a saved run:
 
 ```python
-client.get_run(id)
-client.delete_run(id)
+client.get_run(run.id)
+client.delete_run(run.id)
 ```
 
 ## Features
 
 - Start and end experiment runs
 - Log parameters, metrics, and tags
-- Automatically persist completed runs to local storage
+- Persist completed runs to a local SQLite database
 - Load, list, and delete saved runs
 
 ## Development

{mllogs-0.2.0 → mllogs-0.3.0}/pyproject.toml

@@ -7,7 +7,7 @@ where = ["src"]
 
 [project]
 name = "mllogs"
-version = "0.2.0"
+version = "0.3.0"
 description = "Local experiment logging for machine learning"
 readme = "README.md"
 requires-python = ">=3.11"

mllogs-0.3.0/src/mllogs/__init__.py

@@ -0,0 +1,3 @@
+from .client import MLLogsClient
+
+__all__ = ["MLLogsClient"]

{mllogs-0.2.0 → mllogs-0.3.0}/src/mllogs/client.py

@@ -3,13 +3,20 @@ from datetime import datetime, UTC
 from uuid import uuid4
 
 from .run import Run, RunStatus
-from .storage import LocalFileStore
+from .storage import Storage
+
+from .storage.db import SQLiteStore
 
 
 class MLLogsClient:
-    def __init__(self, file_store: LocalFileStore | None = None):
+    def __init__(self, storage: Storage | None = None):
         self._active_run: Run | None = None
-        self._file_store = file_store if file_store is not None else LocalFileStore()
+
+        if storage is None:
+            db = SQLiteStore()
+            self._storage = Storage(db=db)
+        else:
+            self._storage = storage
 
 
     def _require_active_run(self) -> Run:
@@ -19,6 +26,10 @@ class MLLogsClient:
         return self._active_run
 
 
+    # ------------------
+    # --- Active Run ---
+    # ------------------
+    
     def start_run(
             self,
             name: str | None = None,
@@ -47,22 +58,6 @@ class MLLogsClient:
             status = RunStatus.RUNNING,
             started_at=started_at,
         )
-        # END
-
-
-    def log_param(self, key: str, value: Any) -> None:
-        run = self._require_active_run()
-        run.params[key] = value
-
-
-    def log_metric(self, key: str, value: float) -> None:
-        run = self._require_active_run()
-        run.metrics[key] = value
-
-
-    def set_tag(self, key: str, value: str) -> None:
-        run = self._require_active_run()
-        run.tags[key] = value
 
 
     def end_run(self) -> Run:
@@ -77,21 +72,40 @@ class MLLogsClient:
         run.ended_at = datetime.now(UTC)
         run.status = RunStatus.COMPLETE
 
-        self._file_store.save_run(run)
+        self._storage.save_run(run)
 
         # clear run
         self._active_run = None
 
         return run
+    
+    
+    def log_param(self, key: str, value: Any) -> None:
+        run = self._require_active_run()
+        run.params[key] = value
+
+
+    def log_metric(self, key: str, value: float) -> None:
+        run = self._require_active_run()
+        run.metrics[key] = value
+
+
+    def set_tag(self, key: str, value: str) -> None:
+        run = self._require_active_run()
+        run.tags[key] = value
+
 
+    # ----------------------
+    # --- Persisted runs ---
+    # ----------------------
 
     def get_run(self, run_id: str | None = None) -> Run | None:
-        return self._file_store.load_run(run_id=run_id)
+        return self._storage.load_run(run_id=run_id)
 
 
     def list_runs(self, limit: int | None = None) -> list[Run]:
-        return self._file_store.list_runs(limit=limit)
+        return self._storage.list_runs(limit=limit)
 
 
     def delete_run(self, run_id: str) -> None:
-        self._file_store.delete_run(run_id=run_id)
+        self._storage.delete_run(run_id=run_id)

mllogs-0.3.0/src/mllogs/run.py

@@ -0,0 +1,24 @@
+from datetime import datetime
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class RunStatus(Enum):
+    RUNNING = "running"
+    COMPLETE = "complete"
+    FAILED = "failed"
+
+
+@dataclass
+class Run:
+    id: str
+    started_at: datetime
+    status: RunStatus
+
+    name: str | None = None
+    run_type: str | None =  None
+    ended_at: datetime | None = None
+
+    params: dict[str, str | int | float | bool] = field(default_factory=dict)
+    metrics: dict[str, float] = field(default_factory=dict)
+    tags: dict[str, str] = field(default_factory=dict)

mllogs-0.3.0/src/mllogs/storage/__init__.py

@@ -0,0 +1,5 @@
+from .storage import Storage
+
+__all__ = [
+    "Storage",
+]

mllogs-0.3.0/src/mllogs/storage/db/__init__.py

@@ -0,0 +1,7 @@
+from .base import DBStore
+from .sqlite import SQLiteStore
+
+__all__ = [
+    "DBStore",
+    "SQLiteStore",
+]

mllogs-0.3.0/src/mllogs/storage/db/base.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+
+from mllogs.run import Run
+
+
+class DBStore(ABC):
+    @abstractmethod
+    def save_run(self, run: Run) -> None:
+        ...
+
+    @abstractmethod
+    def load_run(self, run_id: str | None = None) -> Run | None:
+        ...
+
+    @abstractmethod
+    def list_runs(self, limit: int | None = None) -> list[Run]:
+        ...
+
+    @abstractmethod
+    def delete_run(self, run_id: str) -> None:
+        ...

mllogs-0.3.0/src/mllogs/storage/db/sqlite.py

@@ -0,0 +1,227 @@
+from pathlib import Path
+import sqlite3
+import json
+from datetime import datetime
+
+from .base import DBStore
+from mllogs.run import Run, RunStatus
+
+
+class SQLiteStore(DBStore):
+    def __init__(self, db_path: str | Path = ".mllogs/mllogs.db") -> None:
+        self._db_path = Path(db_path)
+
+        self._db_path.parent.mkdir(parents=True, exist_ok=True)
+
+        self._connection = sqlite3.connect(self._db_path)
+        self._connection.row_factory = sqlite3.Row
+        self._connection.execute("PRAGMA foreign_keys = ON")
+
+        self._initialize_schema()
+
+
+    def _initialize_schema(self) -> None:
+        self._connection.executescript(
+            """
+            CREATE TABLE IF NOT EXISTS runs (
+                id          TEXT PRIMARY KEY,
+                started_at  TEXT NOT NULL,
+                status      TEXT NOT NULL,
+                name        TEXT,
+                run_type    TEXT,
+                ended_at    TEXT
+            );
+
+            CREATE TABLE IF NOT EXISTS params (
+                run_id      TEXT NOT NULL,
+                key         TEXT NOT NULL,
+                value       TEXT NOT NULL,
+
+                PRIMARY KEY (run_id, key),
+                FOREIGN KEY (run_id)
+                    REFERENCES runs(id)
+                    ON DELETE CASCADE
+            
+            );
+
+            CREATE TABLE IF NOT EXISTS metrics (
+                run_id          TEXT NOT NULL,
+                key             TEXT NOT NULL,
+                value           REAL NOT NULL,
+
+                PRIMARY KEY (run_id, key),
+                FOREIGN KEY (run_id)
+                    REFERENCES runs(id)
+                    ON DELETE CASCADE
+            );
+
+            CREATE TABLE IF NOT EXISTS tags (
+                run_id          TEXT NOT NULL,
+                key             TEXT NOT NULL,
+                value           TEXT NOT NULL,
+
+                PRIMARY KEY (run_id, key),
+                FOREIGN KEY (run_id)
+                    REFERENCES runs(id)
+                    ON DELETE CASCADE
+            );
+            """     
+        )
+
+
+    def save_run(self, run: Run) -> None:
+        with self._connection:
+            self._connection.execute(
+                """
+                INSERT INTO runs (
+                    id,
+                    started_at,
+                    status,
+                    name,
+                    run_type,
+                    ended_at
+                )
+                VALUES (?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    run.id,
+                    run.started_at.isoformat(),
+                    run.status.value,
+                    run.name,
+                    run.run_type,
+                    run.ended_at.isoformat() if run.ended_at else None,
+                ),
+            )
+
+            self._connection.executemany(
+                """
+                INSERT INTO params (run_id, key, value)
+                VALUES (?, ?, ?)
+                """,
+                [
+                    (run.id, key, json.dumps(value))
+                    for key, value in run.params.items()
+                ],
+            )
+
+            self._connection.executemany(
+                """
+                INSERT INTO metrics (run_id, key, value)
+                VALUES (?, ?, ?)
+                """,
+                [
+                    (run.id, key, value)
+                    for key, value in run.metrics.items()
+                ],
+            )
+
+            self._connection.executemany(
+                """
+                INSERT INTO tags (run_id, key, value)
+                VALUES (?, ?, ?)
+                """,
+                [
+                    (run.id, key, str(value))
+                    for key, value in run.tags.items()
+                ],
+            )
+
+
+    def load_run(self, run_id: str | None = None) -> Run | None:
+        if run_id is None:
+            run_row = self._connection.execute(
+                """
+                SELECT *
+                FROM runs
+                ORDER BY started_at DESC
+                LIMIT 1
+                """
+            ).fetchone()
+        else:
+            run_row = self._connection.execute(
+                "SELECT * FROM runs WHERE id = ?",
+                (run_id,),
+            ).fetchone()
+
+        if run_row is None:
+            return None
+
+        run_id = run_row["id"]
+        
+        param_rows = self._connection.execute(
+            "SELECT key, value FROM params WHERE run_id = ?",
+            (run_id,),
+        ).fetchall()
+
+        metric_rows = self._connection.execute(
+            "SELECT key, value FROM metrics WHERE run_id = ?",
+            (run_id,),
+        ).fetchall()
+
+        tag_rows = self._connection.execute(
+            "SELECT key, value FROM tags WHERE run_id = ?",
+            (run_id,),
+        ).fetchall()
+
+        return Run(
+            id=run_row["id"],
+            started_at=datetime.fromisoformat(run_row["started_at"]),
+            status=RunStatus(run_row["status"]),
+            name=run_row["name"],
+            run_type=run_row["run_type"],
+            ended_at=(
+                datetime.fromisoformat(run_row["ended_at"])
+                if run_row["ended_at"]
+                else None
+            ),
+            params={
+                row["key"]: json.loads(row["value"])
+                for row in param_rows
+            },
+            metrics={
+                row["key"]: row["value"]
+                for row in metric_rows
+            },
+            tags={
+                row["key"]: row["value"]
+                for row in tag_rows
+            },
+        )
+
+
+    def list_runs(self, limit: int | None = None) -> list[Run]:
+        if limit is not None and limit <= 0:
+            raise ValueError("limit must be greater than 0")
+
+        query = """
+            SELECT id
+            FROM runs
+            ORDER BY started_at DESC
+        """
+
+        params = ()
+
+        if limit is not None:
+            query += " LIMIT ?"
+            params = (limit, )
+
+        rows = self._connection.execute(
+            query,
+            params,
+        ).fetchall()
+
+        return [
+            self.load_run(row["id"])
+            for row in rows
+        ]
+
+
+    def delete_run(self, run_id: str) -> None:
+        with self._connection:
+            cursor = self._connection.execute(
+                "DELETE FROM runs WHERE id = ?",
+                (run_id,),
+            )
+
+        if cursor.rowcount == 0:
+            raise KeyError(f"Run not found: {run_id}")

mllogs-0.3.0/src/mllogs/storage/storage.py

@@ -0,0 +1,23 @@
+from .db import DBStore
+
+from mllogs.run import Run
+
+
+class Storage:
+    def __init__(
+        self,
+        db: DBStore,
+    ) -> None:
+        self._db = db
+
+    def save_run(self, run: Run) -> None:
+        self._db.save_run(run)
+
+    def load_run(self, run_id: str | None = None) -> Run | None:
+        return self._db.load_run(run_id)
+
+    def list_runs(self, limit: int | None = None) -> list[Run]:
+        return self._db.list_runs(limit)
+
+    def delete_run(self, run_id: str) -> None:
+        self._db.delete_run(run_id)

{mllogs-0.2.0 → mllogs-0.3.0}/src/mllogs.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mllogs
-Version: 0.2.0
+Version: 0.3.0
 Summary: Local experiment logging for machine learning
 Author: Finn Walsh
 License-Expression: MIT
@@ -45,15 +45,15 @@ client.list_runs()
 Retrieve or delete a saved run:
 
 ```python
-client.get_run(id)
-client.delete_run(id)
+client.get_run(run.id)
+client.delete_run(run.id)
 ```
 
 ## Features
 
 - Start and end experiment runs
 - Log parameters, metrics, and tags
-- Automatically persist completed runs to local storage
+- Persist completed runs to a local SQLite database
 - Load, list, and delete saved runs
 
 ## Development

{mllogs-0.2.0 → mllogs-0.3.0}/src/mllogs.egg-info/SOURCES.txt

@@ -4,12 +4,15 @@ pyproject.toml
 src/mllogs/__init__.py
 src/mllogs/client.py
 src/mllogs/run.py
-src/mllogs/storage.py
 src/mllogs.egg-info/PKG-INFO
 src/mllogs.egg-info/SOURCES.txt
 src/mllogs.egg-info/dependency_links.txt
 src/mllogs.egg-info/requires.txt
 src/mllogs.egg-info/top_level.txt
+src/mllogs/storage/__init__.py
+src/mllogs/storage/storage.py
+src/mllogs/storage/db/__init__.py
+src/mllogs/storage/db/base.py
+src/mllogs/storage/db/sqlite.py
 tests/test_client.py
-tests/test_run.py
-tests/test_storage.py
+tests/test_package.py

{mllogs-0.2.0 → mllogs-0.3.0}/tests/test_client.py

@@ -1,13 +1,24 @@
-from pathlib import Path
 import pytest
 
 from mllogs.run import RunStatus
 from mllogs.client import MLLogsClient
-from mllogs.storage import LocalFileStore
+from mllogs.storage import Storage
+from mllogs.storage.db import SQLiteStore
 
+# ====================
+# ----- Fixtures -----
+# ====================
 
-def test_start_run() -> None:
-    client = MLLogsClient()
+
+@pytest.fixture
+def client(tmp_path):
+    storage=Storage(
+        db=SQLiteStore(tmp_path / "mllogs.db")
+    )
+    return MLLogsClient(storage=storage)
+
+
+def test_start_run(client):
     client.start_run(
         name="run1",
         run_type="training",
@@ -34,14 +45,11 @@ def test_start_run() -> None:
     assert run.ended_at is None
 
 
-def test_end_run(tmp_path: Path) -> None:
-    file_store = LocalFileStore(root_dir=tmp_path)
-    client = MLLogsClient(file_store=file_store)
-
+def test_end_run(client):
     client.start_run()
     run = client.end_run()
 
-    # assert run is ended
+    # assert active run is cleared
     assert client._active_run is None
 
     # assert ended run is complete
@@ -49,12 +57,10 @@ def test_end_run(tmp_path: Path) -> None:
     assert run.ended_at is not None
 
     # assert ended run is persisted to storage
-    assert (tmp_path / "runs" / f"{run.id}.json").is_file()
-
+    assert client.get_run(run.id) == run
 
-def test_mutate_params() -> None:
-    client = MLLogsClient()
 
+def test_log_run_data(client):
     client.start_run()
 
     # log param
@@ -70,9 +76,7 @@ def test_mutate_params() -> None:
     assert client._active_run.tags["ml_model"] == "ridge"
 
 
-def test_ops_requiring_active_run() -> None:
-    client = MLLogsClient()
-
+def test_ops_requiring_active_run(client):
     with pytest.raises(RuntimeError):
         client.log_param("alpha", 0.1)
 
@@ -83,5 +87,4 @@ def test_ops_requiring_active_run() -> None:
         client.set_tag("model", "ridge")
 
     with pytest.raises(RuntimeError):
-        client.end_run()
-        
+        client.end_run()

mllogs-0.3.0/tests/test_package.py

@@ -0,0 +1,4 @@
+from mllogs import MLLogsClient
+
+def test_public_import() -> None:
+    assert MLLogsClient is not None

mllogs-0.2.0/src/mllogs/run.py

@@ -1,88 +0,0 @@
-from datetime import datetime
-from dataclasses import dataclass, field
-from typing import Any
-from enum import Enum
-
-
-class RunStatus(Enum):
-    RUNNING = "running"
-    COMPLETE = "complete"
-    FAILED = "failed"
-
-
-@dataclass
-class Artifact:
-    name: str
-    uri: str
-    artifact_type: str
-
-    def to_dict(self) -> dict[str, str]:
-        return {
-            "name": self.name,
-            "uri": self.uri,
-            "artifact_type": self.artifact_type,
-        }
-
-
-    @classmethod
-    def from_dict(cls, d: dict[str, str]) -> "Artifact":
-        return cls(
-            name = d["name"],
-            uri = d["uri"],
-            artifact_type = d["artifact_type"],
-        )
-
-
-@dataclass
-class Run:
-    id: str
-    started_at: datetime
-    status: RunStatus
-
-    name: str | None = None
-    run_type: str | None =  None
-    ended_at: datetime | None = None
-
-    params: dict[str, Any] = field(default_factory=dict)
-    metrics: dict[str, float] = field(default_factory=dict)
-    tags: dict[str, str] = field(default_factory=dict)
-    artifacts: list[Artifact] = field(default_factory=list)
-
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "id": self.id,
-            "started_at": self.started_at.isoformat(),
-            "status": self.status.value,
-            "name": self.name,
-            "run_type": self.run_type,
-            "ended_at": (
-                self.ended_at.isoformat()
-                if self.ended_at is not None
-                else None
-            ),
-            "params": self.params,
-            "metrics": self.metrics,
-            "tags": self.tags,
-            "artifacts": [a.to_dict() for a in self.artifacts],
-        }
-
-
-    @classmethod
-    def from_dict(cls, d: dict[str, Any]) -> "Run":
-        return cls(
-            id = d["id"],
-            started_at = datetime.fromisoformat(d["started_at"]),
-            status = RunStatus(d["status"]),
-            name = d["name"],
-            run_type = d["run_type"],
-            ended_at = (
-                datetime.fromisoformat(d["ended_at"])
-                if d["ended_at"] is not None
-                else None
-            ),
-            params = d["params"],
-            metrics = d["metrics"],
-            tags = d["tags"],
-            artifacts = [Artifact.from_dict(a) for a in d["artifacts"]],
-        )

mllogs-0.2.0/src/mllogs/storage.py

@@ -1,86 +0,0 @@
-from pathlib import Path
-import json
-
-from .run import Run
-
-
-class LocalFileStore:
-    def __init__(self, root_dir: str | Path = ".mllogs") -> None:
-        """
-        Initializes LocalFileStore and creates runs directory if it
-        does not already exist.
-        """
-        self._root_dir = Path(root_dir)
-        self._runs_dir = self._root_dir / "runs"
-
-        self._runs_dir.mkdir(parents=True, exist_ok=True)
-
-    def save_run(self, run: Run) -> None:
-        """
-        Writes Run to storage as JSON file.
-        """
-        path = self._runs_dir / f"{run.id}.json"
-
-        with path.open("w") as f:
-            json.dump(run.to_dict(), f, indent=4)
-
-
-    def load_run(self, run_id: str | None = None) -> Run | None:
-        """
-        Reads JSON run file from storage and returns a Run.
-
-        Args:
-            - run_id: returns latest run if no argument is passed
-
-        Returns:
-            - Run if exists else None
-        """
-        if run_id is None:
-            runs = self.list_runs(limit=1)
-
-            if not runs:
-                return None
-
-            return runs[0]
-        
-        path = self._runs_dir / f"{run_id}.json"
-
-        with path.open("r") as f:
-            run_dict = json.load(f)
-
-        return Run.from_dict(run_dict)
-
-    
-    def list_runs(self, limit: int | None = None) -> list[Run]:
-        """
-        Returns the most recent runs.
-
-        If limit is None, returns all runs.
-        """
-        if limit is not None and limit <= 0:
-            raise ValueError("limit must be greater than 0")
-
-        paths = sorted(
-            self._runs_dir.glob("*.json"),
-            reverse=True, # latest first
-        )
-
-        if limit is not None:
-            paths = paths[:limit]
-
-        runs = []
-
-        for path in paths:
-            run = self.load_run(path.stem)
-            runs.append(run)
-
-        return runs
-
-
-    def delete_run(self, run_id: str) -> None:
-        """
-        Deletes a run from storage by run ID.
-        """
-        path = self._runs_dir / f"{run_id}.json"
-
-        path.unlink()

mllogs-0.2.0/tests/test_run.py

@@ -1,69 +0,0 @@
-from datetime import datetime, UTC
-
-from mllogs.run import Run, RunStatus
-
-
-def test_run_defaults():
-    started_at = datetime(2000, 1, 1, 0, 0, tzinfo=UTC)
-    run = Run(
-        id="run-123",
-        status=RunStatus.RUNNING,
-        started_at=started_at,
-    )
-
-    assert run.name is None
-    assert run.run_type is None
-    assert run.ended_at is None
-    assert run.params == {}
-    assert run.metrics == {}
-    assert run.tags == {}
-    assert run.artifacts == []
-
-
-def test_to_dict():
-    started_at = datetime(2000, 1, 1, 0, 0, tzinfo=UTC)
-    run = Run(
-        id="run-123",
-        status=RunStatus.RUNNING,
-        started_at=started_at,
-    )
-
-    d = run.to_dict()
-
-    assert d["id"] == "run-123"
-    assert d["status"] == "running"
-    assert d["started_at"] == "2000-01-01T00:00:00+00:00"
-
-
-def test_from_dict():
-    d = {
-        "id": "run-123",
-        "status": "running",
-        "started_at": "2000-01-01T00:00:00+00:00",
-        "name": None,
-        "run_type": None,
-        "ended_at": None,
-        "params": {},
-        "metrics": {},
-        "tags": {},
-        "artifacts": [],
-    }
-
-    run = Run.from_dict(d)
-
-    assert run.started_at == datetime(2000, 1, 1, 0, 0, tzinfo=UTC)
-    assert run.status == RunStatus.RUNNING
-
-
-def test_serialization_round_trip():
-    started_at = datetime(2000, 1, 1, 0, 0, tzinfo=UTC)
-
-    before = Run(
-        id="run-123",
-        status=RunStatus.RUNNING,
-        started_at=started_at,
-    )
-
-    after = Run.from_dict(before.to_dict())
-
-    assert before == after

mllogs-0.2.0/tests/test_storage.py

@@ -1,89 +0,0 @@
-from pathlib import Path
-from datetime import datetime, UTC
-import pytest
-
-from mllogs.run import Run, RunStatus
-from mllogs.storage import LocalFileStore
-
-
-def test_persistence_round_trip(tmp_path: Path) -> None:
-    storage = LocalFileStore(root_dir=tmp_path)
-
-    run = Run(
-        id="run123",
-        status=RunStatus.RUNNING,
-        started_at=datetime.now(UTC),
-    )
-    run_path = storage._runs_dir / f"{run.id}.json"
-
-    # save
-    storage.save_run(run)
-    assert run_path.is_file()
-
-    # load
-    run_after = storage.load_run(run.id)
-    assert run == run_after
-
-    # delete
-    storage.delete_run(run.id)
-    assert not run_path.exists()
-
-
-def test_list_runs(tmp_path: Path) -> None:
-    storage = LocalFileStore(root_dir=tmp_path)
-
-    for run_id in ["001", "002", "003"]:
-        storage.save_run(Run(
-            id=run_id,
-            status=RunStatus.RUNNING,
-            started_at=datetime.now(UTC),
-        ))
-
-    runs = storage.list_runs()
-
-    assert [run.id for run in runs] == ["003", "002", "001"]
-
-
-def test_list_runs_with_limit(tmp_path: Path) -> None:
-    storage = LocalFileStore(root_dir=tmp_path)
-    
-    for run_id in ["001", "002", "003"]:
-        storage.save_run(Run(
-            id=run_id,
-            status=RunStatus.RUNNING,
-            started_at=datetime.now(UTC),
-        ))
-
-    runs = storage.list_runs(limit=2)
-
-    assert [run.id for run in runs] == ["003", "002"]
-
-
-def test_runs_with_invalid_limit(tmp_path: Path) -> None:
-    storage = LocalFileStore(root_dir=tmp_path)
-
-    with pytest.raises(ValueError):
-        storage.list_runs(limit=0)
-
-
-def test_load_latest_run(tmp_path: Path) -> None:
-    storage = LocalFileStore(root_dir=tmp_path)
-        
-    run1 = Run(
-        id="001",
-        status=RunStatus.RUNNING,
-        started_at=datetime.now(UTC),
-    )
-
-    run2 = Run(
-        id="002",
-        status=RunStatus.RUNNING,
-        started_at=datetime.now(UTC),
-    )
-
-    storage.save_run(run1)
-    storage.save_run(run2)
-
-    latest_run = storage.load_run()
-
-    assert latest_run == run2