61 lines
3.1 KiB
Python
61 lines
3.1 KiB
Python
"""Sends a DM through the notifier that a project's config names."""
|
|
import dataclasses
|
|
import pathlib
|
|
import typing
|
|
|
|
from project_config.settings import CONFIG, Notifier, NOTIFIER, NOTIFIERS, ProjectConfig
|
|
from failure import Failure
|
|
from rest_client.json_request import Http
|
|
from project_config.main import located
|
|
from notifier import mattermost, slack
|
|
|
|
# Sends one message, with the credentials already read.
|
|
Sender = typing.Callable[[str], Failure | None]
|
|
|
|
|
|
@dataclasses.dataclass(frozen=True)
|
|
class Backend[C]:
|
|
"""What one notifier needs: `read_config` reads its credentials from an env file, and returns what `send` takes as its config; `send` posts a message with them through `http`; `keys` are the env file's keys."""
|
|
read_config: typing.Callable[[pathlib.Path], C | Failure]
|
|
send: typing.Callable[[C, str, Http], Failure | None]
|
|
http: Http
|
|
keys: tuple[str, ...]
|
|
|
|
|
|
# The one place each notifier is wired to the network: a caller that tests a send passes a table with its own `http`.
|
|
BACKENDS: dict[Notifier, Backend[typing.Any]] = {
|
|
"mattermost": Backend(mattermost.read_config, mattermost.send, mattermost.http_json, mattermost.KEYS),
|
|
"slack": Backend(slack.read_config, slack.send, slack.http_json, slack.KEYS),
|
|
}
|
|
assert tuple(BACKENDS) == NOTIFIERS
|
|
|
|
|
|
def sender_of(project: ProjectConfig, backends: typing.Mapping[Notifier, Backend[typing.Any]]) -> Sender | Failure:
|
|
"""A sender through the project's notifier in backends, with the credentials in its env file read. A Failure where the project names no notifier or its env file cannot be used."""
|
|
if project.notifier is None:
|
|
return Failure(f"{project.folder / CONFIG} sets no `{NOTIFIER}`; set `notifier` to {' or '.join(NOTIFIERS)}, and `env-file` to the file that holds that service's keys ({'; '.join(f'{name}: {', '.join(backend.keys)}' for name, backend in backends.items())})")
|
|
if project.env_file is None:
|
|
return Failure(f"{project.folder / CONFIG} sets `{NOTIFIER}` but no `env-file`, the file that holds its credentials")
|
|
backend = backends[project.notifier]
|
|
config = backend.read_config(project.env_file)
|
|
if isinstance(config, Failure):
|
|
return config
|
|
return lambda message: backend.send(config, message, backend.http)
|
|
|
|
|
|
def notify(text: str, directory: str | None, home: pathlib.Path, backends: typing.Mapping[Notifier, Backend[typing.Any]]) -> Failure | None:
|
|
"""Sends text through the notifier of the project whose checkout holds directory.
|
|
|
|
The DM is skipped where the config names no notifier, since the project hasn't asked for DMs. It is skipped too where no config can be read: loop-claude has stopped with that reason, and without a config there is no notifier to ask."""
|
|
project = located(directory, home)
|
|
if isinstance(project, Failure) or project.notifier is None:
|
|
return None
|
|
sender = sender_of(project, backends)
|
|
return sender if isinstance(sender, Failure) else sender(text)
|
|
|
|
|
|
def sender_in(directory: str | None, home: pathlib.Path, backends: typing.Mapping[Notifier, Backend[typing.Any]]) -> Sender | Failure:
|
|
"""sender_of the project whose checkout holds directory."""
|
|
project = located(directory, home)
|
|
return project if isinstance(project, Failure) else sender_of(project, backends)
|