experimaestro 2.0.0a8__py3-none-any.whl → 2.0.0b4__py3-none-any.whl

experimaestro/cli/filter.py

@@ -1,57 +1,15 @@
-import asyncio
-import logging
-from typing import Any, Callable, Dict, List, Optional
-import pyparsing as pp
-from pathlib import Path
-import json
-from experimaestro.compat import cached_property
+"""Filter expressions for job queries
+
+This module provides a filter expression parser for querying jobs by state,
+tags, and other attributes.
+"""
+
 import re
-from experimaestro.scheduler import JobState
-
-
-class JobInformation:
-    def __init__(self, path: Path, scriptname: str, check: bool = False):
-        self.path = path
-        self.scriptname = scriptname
-        self.check = check
-
-    @cached_property
-    def params(self):
-        try:
-            return json.loads((self.path / "params.json").read_text())
-        except Exception:
-            logging.warning("Could not load params.json in %s", self.path)
-            return {"tags": {}}
-
-    @cached_property
-    def tags(self) -> List[str]:
-        return self.params["tags"]
-
-    @cached_property
-    def state(self) -> Optional[JobState]:
-        if (self.path / f"{self.scriptname}.done").is_file():
-            return JobState.DONE
-        if (self.path / f"{self.scriptname}.failed").is_file():
-            return JobState.ERROR
-        if (self.path / f"{self.scriptname}.pid").is_file():
-            if self.check:
-                if process := self.getprocess():
-                    state = asyncio.run(process.aio_state(0))
-                    if state is None or state.finished:
-                        return JobState.ERROR
-                else:
-                    return JobState.ERROR
-            return JobState.RUNNING
-        else:
-            return None
-
-    def getprocess(self):
-        from experimaestro.connectors import Process
-        from experimaestro.connectors.local import LocalConnector
-
-        connector = LocalConnector.instance()
-        pinfo = json.loads((self.path / f"{self.scriptname}.pid").read_text())
-        return Process.fromDefinition(connector, pinfo)
+from typing import Callable, TYPE_CHECKING
+import pyparsing as pp
+
+if TYPE_CHECKING:
+    from experimaestro.scheduler.state_provider import MockJob
 
 
 # --- classes for processing
@@ -61,14 +19,14 @@ class VarExpr:
     def __init__(self, values):
         (self.varname,) = values
 
-    def get(self, info: JobInformation):
+    def get(self, job: "MockJob"):
         if self.varname == "@state":
-            return info.state.name if info.state else None
+            return job.state.name if job.state else None
 
         if self.varname == "@name":
-            return str(info.path.parent.name)
+            return str(job.path.parent.name)
 
-        return info.tags.get(self.varname, None)
+        return job.tags.get(self.varname, None)
 
     def __repr__(self):
         return f"""VAR<{self.varname}>"""
@@ -81,8 +39,8 @@ class BaseInExpr:
 
 
 class InExpr(BaseInExpr):
-    def filter(self, information: JobInformation):
-        value = self.var.get(information)
+    def filter(self, job: "MockJob"):
+        value = self.var.get(job)
         return value in self.values
 
     def __repr__(self):
@@ -90,8 +48,8 @@ class InExpr(BaseInExpr):
 
 
 class NotInExpr(BaseInExpr):
-    def filter(self, information: JobInformation):
-        value = self.var.get(information)
+    def filter(self, job: "MockJob"):
+        value = self.var.get(job)
         return value not in self.values
 
     def __repr__(self):
@@ -106,25 +64,25 @@ class RegexExpr:
     def __repr__(self):
         return f"""REGEX[{self.varname}, {self.value}]"""
 
-    def matches(self, manager, publication):
+    def matches(self, _manager, publication):
         if self.varname == "tag":
             return self.value in publication.tags
 
         raise AssertionError()
 
-    def filter(self, information: JobInformation):
-        value = self.var.get(information)
+    def filter(self, job: "MockJob"):
+        value = self.var.get(job)
         if not value:
             return False
 
-        return self.re.match(value)
+        return self.regex.match(value)
 
 
 class ConstantString:
     def __init__(self, tokens):
         (self.value,) = tokens
 
-    def get(self, information: JobInformation):
+    def get(self, _job: "MockJob"):
         return self.value
 
     def __repr__(self):
@@ -138,8 +96,8 @@ class EqExpr:
     def __repr__(self):
         return f"""EQ[{self.var1}, {self.var2}]"""
 
-    def filter(self, information: JobInformation):
-        return self.var1.get(information) == self.var2.get(information)
+    def filter(self, job: "MockJob"):
+        return self.var1.get(job) == self.var2.get(job)
 
 
 class LogicExpr:
@@ -149,11 +107,11 @@ class LogicExpr:
         self.operator, self.y = tokens
         self.x = None
 
-    def filter(self, information: JobInformation):
+    def filter(self, job: "MockJob"):
         if self.operator == "and":
-            return self.y.filter(information) and self.x.filter(information)
+            return self.y.filter(job) and self.x.filter(job)
 
-        return self.y.filter(information) or self.x.filter(information)
+        return self.y.filter(job) or self.x.filter(job)
 
     @staticmethod
     def summary(tokens):
@@ -187,7 +145,10 @@ quotedString = pp.QuotedString('"', unquoteResults=True) | pp.QuotedString(
     "'", unquoteResults=True
 )
 
-var = l("@state") | l("@name") | pp.Word(pp.alphas)
+# Tag names can contain letters, digits, underscores, and hyphens
+# First character must be a letter, rest can include digits, underscores, hyphens
+tag_name = pp.Word(pp.alphas, pp.alphanums + "_-")
+var = l("@state") | l("@name") | tag_name
 var.setParseAction(VarExpr)
 
 regexExpr = var + tilde + quotedString
@@ -220,7 +181,14 @@ filterExpr = (
 expr = (matchExpr + pp.Optional(pipe + filterExpr)).setParseAction(LogicExpr.generator)
 
 
-def createFilter(query: str) -> Callable[[Dict[str, Any]], bool]:
-    """Returns a filter object given a query"""
+def createFilter(query: str) -> Callable[["MockJob"], bool]:
+    """Returns a filter function given a query string
+
+    Args:
+        query: Filter expression (e.g., '@state = "DONE" and model = "bm25"')
+
+    Returns:
+        A callable that takes a MockJob and returns True if it matches
+    """
     (r,) = logicExpr.parseString(query, parseAll=True)
     return r.filter

experimaestro/cli/jobs.py

@@ -1,8 +1,6 @@
 # flake8: noqa: T201
-import asyncio
 import subprocess
 from typing import Optional
-from shutil import rmtree
 import click
 from pathlib import Path
 from termcolor import colored, cprint
@@ -34,6 +32,9 @@ def jobs(
     selects jobs where the tag model is "bm25", the tag mode is either
     "a" or "b", and the state is running.
 
+    Note: Jobs are read from the workspace database. If jobs are missing,
+    run 'experimaestro experiments sync' to synchronize the database
+    with the filesystem.
     """
     ws = ctx.obj.workspace = find_workspace(workdir=workdir, workspace=workspace)
     check_xp_path(ctx, None, ws.path)
@@ -44,117 +45,117 @@ def process(
     *,
     experiment="",
     tags="",
-    ready=False,
     clean=False,
     kill=False,
     filter="",
     perform=False,
     fullpath=False,
-    check=False,
+    count=0,
 ):
-    from .filter import createFilter, JobInformation
+    """Process jobs from the workspace database
+
+    Args:
+        workspace: Workspace settings
+        experiment: Filter by experiment ID
+        tags: Show tags in output
+        clean: Clean finished jobs
+        kill: Kill running jobs
+        filter: Filter expression
+        perform: Actually perform kill/clean (dry run if False)
+        fullpath: Show full paths instead of short names
+        count: Limit output to N most recent jobs (0 = no limit)
+    """
+    from .filter import createFilter
+    from experimaestro.scheduler.state_provider import WorkspaceStateProvider
     from experimaestro.scheduler import JobState
 
-    _filter = createFilter(filter) if filter else lambda x: True
-
-    # Get all jobs from experiments
-    job2xp = {}
-
-    path = workspace.path
-    for p in (path / "xp").glob("*"):
-        for job in p.glob("jobs/*/*"):
-            job_path = job.resolve()
-            if job_path.is_dir():
-                job2xp.setdefault(job_path.name, set()).add(p.name)
-
-        if (p / "jobs.bak").is_dir():
-            cprint(f"  Experiment {p.name} has not finished yet", "red")
-            if (not perform) and (kill or clean):
-                cprint(
-                    "  Preventing kill/clean (use --perform if you want to)", "yellow"
-                )
-                kill = False
-                clean = False
-
-    # Now, process jobs
-    for job in path.glob("jobs/*/*"):
-        info = None
-        p = job.resolve()
-        if p.is_dir():
-            *_, scriptname = p.parent.name.rsplit(".", 1)
-            xps = job2xp.get(job.name, set())
-            if experiment and experiment not in xps:
-                continue
-
-            info = JobInformation(p, scriptname, check=check)
-            job_str = (
-                (str(job.resolve()) if fullpath else f"{job.parent.name}/{job.name}")
-                + " "
-                + ",".join(xps)
-            )
-
-            if filter:
-                if not _filter(info):
-                    continue
-
-            if info.state is None:
-                print(colored(f"NODIR   {job_str}", "red"), end="")
-            elif info.state.running():
+    _filter = createFilter(filter) if filter else None
+
+    # Get state provider (write mode for kill/clean operations)
+    read_only = not (kill or clean)
+    provider = WorkspaceStateProvider.get_instance(workspace.path, read_only=read_only)
+
+    try:
+        # Get all jobs from the database
+        all_jobs = provider.get_all_jobs()
+
+        # Filter by experiment if specified
+        if experiment:
+            all_jobs = [j for j in all_jobs if j.experiment_id == experiment]
+
+        # Apply filter expression
+        if _filter:
+            all_jobs = [j for j in all_jobs if _filter(j)]
+
+        # Sort by submission time (most recent first)
+        # Jobs without submittime go to the end
+        all_jobs.sort(key=lambda j: j.submittime or 0, reverse=True)
+
+        # Limit to N most recent jobs if count is specified
+        if count > 0:
+            all_jobs = all_jobs[:count]
+
+        if not all_jobs:
+            cprint("No jobs found.", "yellow")
+            return
+
+        # Process each job
+        for job in all_jobs:
+            job_str = str(job.path) if fullpath else f"{job.task_id}/{job.identifier}"
+
+            # Add experiment info
+            if job.experiment_id:
+                job_str += f" [{job.experiment_id}]"
+
+            if job.state is None or job.state == JobState.UNSCHEDULED:
+                print(colored(f"UNSCHED {job_str}", "red"), end="")
+            elif job.state.running():
                 if kill:
                     if perform:
-                        process = info.getprocess()
-                        if process is None:
-                            cprint(
-                                "internal error – no process could be retrieved",
-                                "red",
-                            )
+                        if provider.kill_job(job, perform=True):
+                            cprint(f"KILLED  {job_str}", "light_red")
                         else:
-                            cprint(f"KILLING {process}", "light_red")
-                            process.kill()
+                            cprint(f"KILL FAILED {job_str}", "red")
                     else:
-                        print("KILLING (not performing)", process)
-                print(
-                    colored(f"{info.state.name:8}{job_str}", "yellow"),
-                    end="",
-                )
-            elif info.state == JobState.DONE:
-                print(
-                    colored(f"DONE    {job_str}", "green"),
-                    end="",
-                )
-            elif info.state == JobState.ERROR:
+                        cprint(f"KILLING {job_str} (dry run)", "yellow")
+                else:
+                    print(colored(f"{job.state.name:8}{job_str}", "yellow"), end="")
+            elif job.state == JobState.DONE:
+                print(colored(f"DONE    {job_str}", "green"), end="")
+            elif job.state == JobState.ERROR:
                 print(colored(f"FAIL    {job_str}", "red"), end="")
             else:
-                print(
-                    colored(f"{info.state.name:8}{job_str}", "red"),
-                    end="",
-                )
+                print(colored(f"{job.state.name:8}{job_str}", "red"), end="")
 
-        else:
-            if not ready:
-                continue
-            print(colored(f"READY {job_path}", "yellow"), end="")
+            # Show tags if requested
+            if tags and job.tags:
+                print(f""" {" ".join(f"{k}={v}" for k, v in job.tags.items())}""")
+            elif not (kill and perform):
+                print()
 
-        if tags:
-            print(f""" {" ".join(f"{k}={v}" for k, v in info.tags.items())}""")
-        else:
-            print()
+            # Clean finished jobs
+            if clean and job.state and job.state.finished():
+                if perform:
+                    if provider.clean_job(job, perform=True):
+                        cprint("  Cleaned", "red")
+                    else:
+                        cprint("  Clean failed", "red")
+                else:
+                    cprint("  Would clean (dry run)", "yellow")
 
-        if clean and info.state and info.state.finished():
-            if perform:
-                cprint("Cleaning...", "red")
-                rmtree(p)
-            else:
-                cprint("Cleaning... (not performed)", "red")
-    print()
+        print()
+
+    finally:
+        # Close provider if we created it for write mode
+        if not read_only:
+            provider.close()
 
 
 @click.option("--experiment", default=None, help="Restrict to this experiment")
 @click.option("--tags", is_flag=True, help="Show tags")
-@click.option("--ready", is_flag=True, help="Include tasks which are not yet scheduled")
 @click.option("--filter", default="", help="Filter expression")
 @click.option("--fullpath", is_flag=True, help="Prints full paths")
-@click.option("--no-check", is_flag=True, help="Check that running jobs")
+@click.option("--count", "-c", default=0, type=int, help="Limit to N most recent jobs")
 @jobs.command()
 @click.pass_context
 def list(
@@ -162,24 +163,22 @@ def list(
     experiment: str,
     filter: str,
     tags: bool,
-    ready: bool,
     fullpath: bool,
-    no_check: bool,
+    count: int,
 ):
+    """List all jobs in the workspace (sorted by submission date, most recent first)"""
     process(
         ctx.obj.workspace,
         experiment=experiment,
         filter=filter,
         tags=tags,
-        ready=ready,
         fullpath=fullpath,
-        check=not no_check,
+        count=count,
     )
 
 
 @click.option("--experiment", default=None, help="Restrict to this experiment")
 @click.option("--tags", is_flag=True, help="Show tags")
-@click.option("--ready", is_flag=True, help="Include tasks which are not yet scheduled")
 @click.option("--filter", default="", help="Filter expression")
 @click.option("--perform", is_flag=True, help="Really perform the killing")
 @click.option("--fullpath", is_flag=True, help="Prints full paths")
@@ -190,17 +189,15 @@ def kill(
     experiment: str,
     filter: str,
     tags: bool,
-    ready: bool,
     fullpath: bool,
     perform: bool,
-    check: bool,
 ):
+    """Kill running jobs"""
     process(
         ctx.obj.workspace,
         experiment=experiment,
         filter=filter,
         tags=tags,
-        ready=ready,
         kill=True,
         perform=perform,
         fullpath=fullpath,
@@ -209,7 +206,6 @@ def kill(
 
 @click.option("--experiment", default=None, help="Restrict to this experiment")
 @click.option("--tags", is_flag=True, help="Show tags")
-@click.option("--ready", is_flag=True, help="Include tasks which are not yet scheduled")
 @click.option("--filter", default="", help="Filter expression")
 @click.option("--perform", is_flag=True, help="Really perform the cleaning")
 @click.option("--fullpath", is_flag=True, help="Prints full paths")
@@ -220,16 +216,15 @@ def clean(
     experiment: str,
     filter: str,
     tags: bool,
-    ready: bool,
     fullpath: bool,
     perform: bool,
 ):
+    """Clean finished jobs (delete directories and DB entries)"""
     process(
         ctx.obj.workspace,
         experiment=experiment,
         filter=filter,
         tags=tags,
-        ready=ready,
         clean=True,
         perform=perform,
         fullpath=fullpath,
@@ -244,25 +239,81 @@ def clean(
 @jobs.command()
 @click.pass_context
 def log(ctx, jobid: str, follow: bool, std: bool):
+    """View job log (stderr by default, stdout with --std)
+
+    JOBID format: task.name/hash (e.g., mymodule.MyTask/abc123)
+    """
     task_name, task_hash = jobid.split("/")
     _, name = task_name.rsplit(".", 1)
-    path = (
+    log_path = (
         ctx.obj.workspace.path
         / "jobs"
         / task_name
         / task_hash
         / f"""{name}.{'out' if std else 'err'}"""
     )
+    if not log_path.exists():
+        cprint(f"Log file not found: {log_path}", "red")
+        return
     if follow:
-        subprocess.run(["tail", "-f", path])
+        subprocess.run(["tail", "-f", log_path])
     else:
-        subprocess.run(["less", "-r", path])
+        subprocess.run(["less", "-r", log_path])
 
 
 @click.argument("jobid", type=str)
 @jobs.command()
 @click.pass_context
 def path(ctx, jobid: str):
+    """Print the path to a job directory
+
+    JOBID format: task.name/hash (e.g., mymodule.MyTask/abc123)
+    """
     task_name, task_hash = jobid.split("/")
-    path = ctx.obj.workspace.path / "jobs" / task_name / task_hash
-    print(path)
+    job_path = ctx.obj.workspace.path / "jobs" / task_name / task_hash
+    if not job_path.exists():
+        cprint(f"Job directory not found: {job_path}", "red")
+        return
+    print(job_path)
+
+
+@click.option("--perform", is_flag=True, help="Actually delete orphan partials")
+@jobs.command("cleanup-partials")
+@click.pass_context
+def cleanup_partials(ctx, perform: bool):
+    """Clean up orphan partial directories
+
+    Partial directories are shared checkpoint locations created by
+    subparameters. When all jobs using a partial are deleted, the
+    partial becomes orphaned and can be cleaned up.
+
+    This command finds all orphan partials and deletes them (or shows
+    what would be deleted in dry-run mode).
+    """
+    from experimaestro.scheduler.state_provider import WorkspaceStateProvider
+
+    provider = WorkspaceStateProvider.get_instance(
+        ctx.obj.workspace.path, read_only=not perform
+    )
+
+    try:
+        orphan_paths = provider.cleanup_orphan_partials(perform=perform)
+
+        if not orphan_paths:
+            cprint("No orphan partials found.", "green")
+            return
+
+        if perform:
+            cprint(f"Cleaned {len(orphan_paths)} orphan partial(s):", "green")
+        else:
+            cprint(f"Found {len(orphan_paths)} orphan partial(s) (dry run):", "yellow")
+
+        for path in orphan_paths:
+            if perform:
+                print(colored(f"  Deleted: {path}", "red"))
+            else:
+                print(colored(f"  Would delete: {path}", "yellow"))
+
+    finally:
+        if perform:
+            provider.close()