feat: planning and runtime skeleton

.github/workflows/test.yml

@@ -0,0 +1,62 @@
+name: CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install just
+      uses: taiki-e/install-action@just
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v4
+      with:
+        enable-cache: true
+        cache-dependency-glob: "uv.lock"
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.12"
+
+    - name: Install dependencies
+      run: uv sync --all-extras --dev
+
+    - name: Lint
+      run: just lint
+
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install just
+      uses: taiki-e/install-action@just
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v4
+      with:
+        enable-cache: true
+        cache-dependency-glob: "uv.lock"
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install dependencies
+      run: uv sync --all-extras --dev
+
+    - name: Test
+      run: just test

Justfile

@@ -0,0 +1,23 @@
+default:
+    @just --list
+
+test:
+    @uv run pytest
+
+test-s:
+    @uv run pytest -s
+
+ruff:
+    uv run ruff format lab
+
+pyright:
+    uv run pyright lab
+
+lint:
+    just ruff
+    just pyright
+
+lint-file file:
+    - ruff {{file}}
+    - pyright {{file}}
+

README.md

@@ -1,2 +1,7 @@
 # lab
 A CLI tool for managing computational science
+
+## Usage
+
+Running `lab run .` will search for a `Labfile` in the directory, and then run the experiments defined there. `lab`
+will automatically resolve dependencies between experiments and run them in the right order.

lab/cli/cli.py

@@ -1,12 +1,19 @@
-import typer
+import click
+from dishka.integrations.click import setup_dishka
+from lab.cli.commands.plan import plan
 
-from lab.cli.commands import exp, run
+from lab.cli.commands.run import run
+from lab.di import DI
 
-app = typer.Typer()
 
+def start():
+    @click.group()
+    @click.pass_context
+    def main(context: click.Context):
+        di = DI()
+        setup_dishka(container=di.container, context=context, auto_inject=True)
 
-def main():
-    exp.attach(app, name="exp")
-    run.attach(app, name="run")
+    main.command(name="plan")(plan)
+    main.command(name="run")(run)
 
-    app()
+    main()

lab/cli/commands/plan.py

@@ -0,0 +1,20 @@
+from pathlib import Path
+from dishka import FromDishka
+import rich
+import click
+
+from lab.core.ui import UserInterface
+from lab.project.service.labfile import LabfileService
+from lab.project.service.plan import PlanService
+
+
+@click.argument("path", type=click.Path(exists=True, path_type=Path))
+def plan(path: Path, ui: FromDishka[UserInterface]):
+    """Generate execution plan from Labfile"""
+    ui.print(f"Generating plan for [b]{path.resolve()}[/b]\n")
+    labfile_service = LabfileService()
+    plan_service = PlanService()
+    project = labfile_service.parse(path)
+
+    plan = plan_service.create_execution_plan(project)
+    ui.print(str(plan))

lab/cli/commands/run.py

@@ -1,24 +1,53 @@
 from pathlib import Path
-from typing import Annotated
-import rich
-import typer
+import logging
+import click
+from dishka import FromDishka
 
-from lab.service.experiment import ExperimentService
-from lab.service.labfile import LabfileService
-from lab.service.pipeline import PipelineService
+from lab.cli.utils import coro
+from lab.core.logging import setup_logging
+from lab.core.ui import UserInterface
+from lab.project.service.labfile import LabfileService
+from lab.project.service.plan import PlanService
+from lab.runtime.runtime import Runtime
 
+logger = logging.getLogger("lab")
 
-def run(path: Annotated[Path, typer.Argument(help="Path to Labfile")]):
-    rich.print(f"Running [b]{path.resolve()}[/b]\n")
-    labfile_service = LabfileService()
-    project = labfile_service.parse(path)
 
-    experiment_service = ExperimentService()
-    pipeline_service = PipelineService(experiment_service=experiment_service)
+@click.argument("path", type=click.Path(exists=True, path_type=Path))
+@coro
+async def run(
+    path: Path,
+    ui: FromDishka[UserInterface],
+    runtime: FromDishka[Runtime],
+    labfile_service: FromDishka[LabfileService],
+    plan_service: FromDishka[PlanService],
+):
+    """Run experiments defined in Labfile"""
+    setup_logging(Path("~/.local/lab/logs/lab.log"))
 
-    pipeline = pipeline_service.create_pipeline(project)
-    pipeline_service.run(pipeline)
+    try:
+        ui.display_start(str(path.resolve()))
 
+        # Load and parse project
+        logger.debug("Loading project", extra={"context": {"path": str(path)}})
+        labfile_service = LabfileService()
+        project = labfile_service.parse(path)
 
-def attach(app: typer.Typer, *, name: str):
-    app.command(name=name)(run)
+        # Create execution plan
+        plan_service = PlanService()
+        plan = plan_service.create_execution_plan(project)
+
+        await runtime.start(plan)
+
+        # # Execute experiments with progress display
+        # with ui.create_progress() as progress:
+        #     task = progress.add_task(
+        #         "Running experiments...", total=len(plan.ordered_experiments)
+        #     )
+
+        ui.display_success()
+
+    except Exception as e:
+        logger.exception("Execution failed")
+        ui.display_error(message="Execution failed", details=str(e))
+        raise

lab/cli/utils.py

@@ -0,0 +1,11 @@
+import asyncio
+from functools import wraps
+from typing import Callable
+
+
+def coro(f: Callable):
+    @wraps(f)
+    def wrapper(*args, **kwargs):
+        return asyncio.run(f(*args, **kwargs))
+
+    return wrapper

lab/core/database.py

@@ -0,0 +1,29 @@
+from typing import Optional
+from sqlalchemy import create_engine, Engine
+from sqlalchemy.pool import StaticPool
+
+
+def make_db(database_url: Optional[str] = None) -> Engine:
+    """Create a database engine using SQLAlchemy.
+
+    Args:
+        database_url: Optional database URL. Defaults to in-memory SQLite.
+
+    Returns:
+        SQLAlchemy Engine instance
+    """
+    if database_url is None:
+        database_url = "sqlite:///:memory:"
+
+    connect_args = (
+        {"check_same_thread": False} if database_url.startswith("sqlite") else {}
+    )
+
+    return create_engine(
+        database_url,
+        # For SQLite in-memory DB, use StaticPool to maintain a single connection
+        poolclass=StaticPool if database_url == "sqlite:///:memory:" else None,
+        connect_args=connect_args,
+        # Echo SQL for debugging
+        echo=False,
+    )

lab/core/logging.py

@@ -0,0 +1,54 @@
+import json
+import logging.config
+import os
+import yaml
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+
+class JSONFormatter(logging.Formatter):
+    """JSON formatter for structured logging"""
+
+    def format(self, record: logging.LogRecord) -> str:
+        log_obj = {
+            "timestamp": datetime.fromtimestamp(record.created).isoformat(),
+            "level": record.levelname,
+            "logger": record.name,
+            "message": record.getMessage(),
+            "context": getattr(record, "context", {}),
+        }
+        if record.exc_info:
+            log_obj["exception"] = self.formatException(record.exc_info)
+        return json.dumps(log_obj)
+
+
+def load_logging_config(path: Path) -> dict:
+    config_template = path.read_text()
+
+    config_str = config_template.replace(
+        "_LOG_FILE_", os.getenv("LOG_FILE", "/var/log/default.log")
+    )
+
+    return yaml.safe_load(config_str)
+
+
+def setup_logging(log_file: Optional[Path] = None) -> None:
+    """Configure application logging from YAML file"""
+    if log_file:
+        # Ensure log directory exists
+        log_file = log_file.expanduser().resolve()
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+
+        # Set environment variable for template substitution
+        os.environ["LOG_FILE"] = str(log_file)
+        # Load config file
+        config_path = Path(__file__).parent / "logging.yaml"
+        config = load_logging_config(config_path)
+
+        # Apply configuration
+        logging.config.dictConfig(config)
+    else:
+        # If no log file specified, use null handler
+        logger = logging.getLogger("lab")
+        logger.addHandler(logging.NullHandler())

lab/core/logging.yaml

@@ -0,0 +1,41 @@
+version: 1
+disable_existing_loggers: false
+
+formatters:
+  json:
+    (): lab.core.logging.JSONFormatter
+  simple:
+    format: '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+
+handlers:
+  file:
+    class: logging.handlers.RotatingFileHandler
+    formatter: json
+    filename: _LOG_FILE_
+    maxBytes: 10485760  # 10MB
+    backupCount: 5
+    encoding: utf8
+
+  null_handler:
+    class: logging.NullHandler
+
+loggers:
+  lab:
+    level: DEBUG
+    handlers: [file]
+    propagate: false
+
+  # Third party loggers
+  urllib3:
+    level: WARNING
+    handlers: [null_handler]
+    propagate: false
+
+  asyncio:
+    level: WARNING
+    handlers: [null_handler]
+    propagate: false
+
+root:
+  level: WARNING
+  handlers: [null_handler]