README

Bases: Plugin

              flowchart TD
              liblaf.cherries.plugins.Comet[Comet]
              liblaf.cherries.core.plugin._plugin.Plugin[Plugin]

                              liblaf.cherries.core.plugin._plugin.Plugin --> liblaf.cherries.plugins.Comet
                


              click liblaf.cherries.plugins.Comet href "" "liblaf.cherries.plugins.Comet"
              click liblaf.cherries.core.plugin._plugin.Plugin href "" "liblaf.cherries.core.plugin._plugin.Plugin"
            

Send run metadata, parameters, and metrics to Comet.

Attributes:

Parameters:

• name (PluginName, default: <dynamic> ) –
• run (Run) –
• disabled (bool, default: False ) –

Methods:

• end –

  End the active Comet experiment after Git finalization.

• log_asset –

  Reserve the asset hook for future Comet artifact support.

• log_metric –

  Log one metric to Comet.

• log_metrics –

  Log multiple metrics to Comet.

• log_other –

  Log one metadata value to Comet.

• log_others –

  Log multiple metadata values to Comet.

• log_param –

  Log one parameter to Comet.

• log_params –

  Log multiple parameters to Comet.

• start –

  Start a Comet experiment for the owning run.

disabled: bool = attrs.field(default=False)

experiment: CometExperiment

name: PluginName = attrs.field(
    default=attrs.Factory(_default_name, takes_self=True),
    kw_only=True,
)

run: Run = attrs.field(repr=False)

end(exc: BaseException | None = None) -> None

49
50
51
52
53

@core.impl(after=("Git",))
def end(self, exc: BaseException | None = None) -> None:
    """End the active Comet experiment after Git finalization."""
    del exc
    self.experiment.end()

log_asset(
    path: Path,
    *,
    metadata: Mapping[str, Any] | None = None,
    report: bool = True,
) -> None

55
56
57
58
59
60
61
62
63

@core.impl
def log_asset(
    self,
    path: Path,
    *,
    metadata: Mapping[str, Any] | None = None,
    report: bool = True,
) -> None:
    """Reserve the asset hook for future Comet artifact support."""

log_metric(
    name: str, value: float, *, step: int, time: datetime
) -> None

66
67
68
69
70

@core.impl
def log_metric(self, name: str, value: float, *, step: int, time: datetime) -> None:
    """Log one metric to Comet."""
    del time
    return self.experiment.log_metric(name, value, step=step)

log_metrics(
    metrics: dict[str, float], *, step: int, time: datetime
) -> None

72
73
74
75
76
77
78

@core.impl
def log_metrics(
    self, metrics: dict[str, float], *, step: int, time: datetime
) -> None:
    """Log multiple metrics to Comet."""
    del time
    return self.experiment.log_metrics(metrics, step=step)

log_other(name: str, value: Any) -> None

80
81
82
83

@core.impl
def log_other(self, name: str, value: Any) -> None:
    """Log one metadata value to Comet."""
    return self.experiment.log_other(name, value)

log_others(others: dict[str, Any]) -> None

85
86
87
88

@core.impl
def log_others(self, others: dict[str, Any]) -> None:
    """Log multiple metadata values to Comet."""
    return self.experiment.log_others(others)

log_param(name: str, value: Any) -> None

90
91
92
93

@core.impl
def log_param(self, name: str, value: Any) -> None:
    """Log one parameter to Comet."""
    return self.experiment.log_parameter(name, value)

log_params(params: dict[str, Any]) -> None

95
96
97
98

@core.impl
def log_params(self, params: dict[str, Any]) -> None:
    """Log multiple parameters to Comet."""
    return self.experiment.log_parameters(params)

start() -> None

34
35
36
37
38
39
40
41
42
43
44
45
46
47

@core.impl
def start(self) -> None:
    """Start a Comet experiment for the owning run."""
    try:
        exp: comet.CometExperiment = comet.start(
            project_name=self.run.project_name,
            experiment_config=comet.ExperimentConfig(
                disabled=self.disabled, name=self.run.run_name, tags=self.run.tags
            ),
        )
    except ValueError:
        logger.exception("")
    else:
        self.run.log_other("cherries/comet/url", exp.url)

Bases: Plugin

              flowchart TD
              liblaf.cherries.plugins.Git[Git]
              liblaf.cherries.core.plugin._plugin.Plugin[Plugin]

                              liblaf.cherries.core.plugin._plugin.Plugin --> liblaf.cherries.plugins.Git
                


              click liblaf.cherries.plugins.Git href "" "liblaf.cherries.plugins.Git"
              click liblaf.cherries.core.plugin._plugin.Plugin href "" "liblaf.cherries.core.plugin._plugin.Plugin"
            

Record Git metadata and optionally commit dirty experiment outputs.

Attributes:

Parameters:

• name (PluginName, default: <dynamic> ) –
• run (Run) –
• commit (bool, default: False ) –
• verify (bool, default: False ) –

Methods:

• end –

  Commit dirty changes if configured and log the final Git SHA.

commit: bool = attrs.field(default=False, kw_only=True)

name: PluginName = attrs.field(
    default=attrs.Factory(_default_name, takes_self=True),
    kw_only=True,
)

repo: Repo | None

run: Run = attrs.field(repr=False)

verify: bool = attrs.field(default=False, kw_only=True)

end(exc: BaseException | None = None) -> None

31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

@core.impl(before=("Comet",))
def end(self, exc: BaseException | None = None) -> None:
    """Commit dirty changes if configured and log the final Git SHA."""
    del exc
    if self.repo is None:
        return
    if self.commit and self.repo.is_dirty(untracked_files=True):
        message: str = self._make_commit_message()
        try:
            self.repo.git.add(all=True)
            subprocess.run(["git", "status"], check=False)
            self.repo.git.commit(message=message, no_verify=not self.verify)
        except git.GitCommandError:
            logger.exception("")
    self.run.log_other("cherries/git/sha", self.repo.head.commit.hexsha)

Bases: Plugin

              flowchart TD
              liblaf.cherries.plugins.Local[Local]
              liblaf.cherries.core.plugin._plugin.Plugin[Plugin]

                              liblaf.cherries.core.plugin._plugin.Plugin --> liblaf.cherries.plugins.Local
                


              click liblaf.cherries.plugins.Local href "" "liblaf.cherries.plugins.Local"
              click liblaf.cherries.core.plugin._plugin.Plugin href "" "liblaf.cherries.core.plugin._plugin.Plugin"
            

Copy the entrypoint, logs, and artifacts into .cherries/runs/.

Attributes:

Parameters:

• name (PluginName, default: <dynamic> ) –
• run (Run) –

Methods:

• log_asset –

  Copy path under the snapshot's assets/ directory.

• start –

  Configure local logging and copy the entrypoint.

folder: Path

log_file: Path

name: PluginName = attrs.field(
    default=attrs.Factory(_default_name, takes_self=True),
    kw_only=True,
)

run: Run = attrs.field(repr=False)

log_asset(
    path: Path,
    *,
    metadata: Mapping[str, Any] | None = None,
    report: bool = True,
) -> None

49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

@core.impl
def log_asset(
    self,
    path: Path,
    *,
    metadata: Mapping[str, Any] | None = None,
    report: bool = True,
) -> None:
    """Copy `path` under the snapshot's `assets/` directory."""
    del metadata, report
    if path.is_relative_to(self.run.working_dir):
        target: Path = self.folder / path.relative_to(self.run.working_dir)
    else:
        target: Path = self.folder / "assets" / path.name
    self._copy(path, target)

start() -> None

43
44
45
46
47

@core.impl(after=("Logging",))
def start(self) -> None:
    """Configure local logging and copy the entrypoint."""
    self._config_logging()
    self._copy(self.run.entrypoint, self.folder / "src" / self.run.entrypoint.name)

Bases: Plugin

              flowchart TD
              liblaf.cherries.plugins.Logging[Logging]
              liblaf.cherries.core.plugin._plugin.Plugin[Plugin]

                              liblaf.cherries.core.plugin._plugin.Plugin --> liblaf.cherries.plugins.Logging
                


              click liblaf.cherries.plugins.Logging href "" "liblaf.cherries.plugins.Logging"
              click liblaf.cherries.core.plugin._plugin.Plugin href "" "liblaf.cherries.core.plugin._plugin.Plugin"
            

Initialize Python logging and mirror metrics to the run log.

Attributes:

Parameters:

• name (PluginName, default: <dynamic> ) –
• run (Run) –

Methods:

• log_metric –

  Write one metric to the Python logger.

• log_metrics –

  Write multiple metrics to the Python logger.

• start –

  Initialize liblaf.logging for the run log file.

log_file: Path

name: PluginName = attrs.field(
    default=attrs.Factory(_default_name, takes_self=True),
    kw_only=True,
)

run: Run = attrs.field(repr=False)

log_metric(
    name: str, value: float, *, step: int, time: datetime
) -> None

39
40
41
42
43

@core.impl
def log_metric(self, name: str, value: float, *, step: int, time: datetime) -> None:
    """Write one metric to the Python logger."""
    del time
    logger.info("step: %s, %s: %s", step, name, value)

log_metrics(
    metrics: Mapping[str, float],
    *,
    step: int,
    time: datetime,
) -> None

45
46
47
48
49
50
51

@core.impl
def log_metrics(
    self, metrics: Mapping[str, float], *, step: int, time: datetime
) -> None:
    """Write multiple metrics to the Python logger."""
    del time
    logger.info("step: %s, %s", step, metrics)

start(*args, **kwargs) -> None

33
34
35
36
37

@core.impl(before=("Local",))
def start(self, *args, **kwargs) -> None:
    """Initialize `liblaf.logging` for the run log file."""
    del args, kwargs
    liblaf.logging.init(file=self.log_file, force=True)