dron 0.1.20241008__py3-none-any.whl → 0.2.20251011__py3-none-any.whl

dron/api.py

@@ -4,8 +4,8 @@ import getpass
 import inspect
 import re
 import sys
+from collections.abc import Sequence
 from dataclasses import dataclass
-from typing import Sequence
 
 from .common import (
     IS_SYSTEMD,
@@ -19,6 +19,7 @@ OnFailureAction = str
 
 UnitName = str
 
+
 @dataclass
 class Job:
     when: When | None
@@ -95,12 +96,12 @@ def job(
 
 
 __all__ = (
-    'When',
+    'Command',
+    'Job',  # todo maybe don't expose it?
     'OnCalendar',
     'OnFailureAction',
-    'Command',
-    'wrap',
+    'When',
     'job',
     'notify',
-    'Job',  # todo maybe don't expose it?
+    'wrap',
 )

dron/cli.py

@@ -1,32 +1,25 @@
 from __future__ import annotations
 
-import argparse
-import os
-import shutil
-import subprocess
+import socket
 import sys
-from pathlib import Path
 from pprint import pprint
-from tempfile import TemporaryDirectory
 
 import click
 
-from . import launchd, systemd
+from . import common, launchd, systemd
 from .api import UnitName
 from .common import (
     IS_SYSTEMD,
-    MANAGED_MARKER,
     MonitorParams,
     Unit,
     escape,
     logger,
     print_monitor,
+    set_verify_off,
 )
 from .dron import (
-    DRONTAB,
     apply,
     do_lint,
-    drontab_dir,
     get_entries_for_monitor,
     load_jobs,
     manage,
@@ -34,128 +27,8 @@ from .dron import (
 )
 
 
-def cmd_edit() -> None:
-    drontab = DRONTAB
-    if not drontab.exists():
-        if click.confirm(f"tabfile {drontab} doesn't exist. Create?", default=True):
-            drontab.write_text(
-                '''\
-#!/usr/bin/env python3
-from dron.api import job
-
-def jobs():
-    # yield job(
-    #     'hourly',
-    #     '/bin/echo 123',
-    #     unit_name='test_unit'
-    # )
-    pass
-'''.lstrip()
-            )
-        else:
-            raise RuntimeError()
-
-    editor = os.environ.get('EDITOR')
-    if editor is None:
-        logger.warning('No EDITOR! Fallback to nano')
-        editor = 'nano'
-
-    with TemporaryDirectory() as tdir:
-        tpath = Path(tdir) / 'drontab'
-        shutil.copy2(drontab, tpath)
-
-        orig_mtime = tpath.stat().st_mtime
-        while True:
-            res = subprocess.run([editor, str(tpath)], check=True)
-
-            new_mtime = tpath.stat().st_mtime
-            if new_mtime == orig_mtime:
-                logger.warning('No notification made')
-                return
-
-            ex: Exception | None = None
-            try:
-                state = do_lint(tabfile=tpath)
-            except Exception as e:
-                logger.exception(e)
-                ex = e
-            else:
-                try:
-                    manage(state=state)
-                except Exception as ee:
-                    logger.exception(ee)
-                    ex = ee
-            if ex is not None:
-                if click.confirm('Got errors. Try again?', default=True):
-                    continue
-                raise ex
-
-            drontab.write_text(tpath.read_text())  # handles symlinks correctly
-            logger.info(f"Wrote changes to {drontab}. Don't forget to commit!")
-            break
-
-        # TODO show git diff?
-        # TODO perhaps allow to carry on regardless? not sure..
-        # not sure how much we can do without modifying anything...
-
-
-def cmd_lint(tabfile: Path) -> None:
-    _state = do_lint(tabfile)
-    logger.info('all good')
-
-
-def cmd_apply(tabfile: Path) -> None:
-    apply(tabfile)
-
-
-def cmd_print(*, tabfile: Path, pretty: bool) -> None:
-    dtab_dir = Path(drontab_dir())
-    jobs = list(load_jobs(tabfile=tabfile, ppath=dtab_dir))
-
-    if pretty:
-        import tabulate
-
-        items = [
-            {
-                'UNIT': job.unit_name,
-                'SCHEDULE': job.when,
-                'COMMAND': escape(job.command),
-            }
-            for job in jobs
-        ]
-        print(tabulate.tabulate(items, headers="keys"))
-    else:
-        for j in jobs:
-            print(j)
-
-
-def cmd_run(*, unit: Unit, do_exec: bool) -> None:
-    if IS_SYSTEMD:
-        return systemd.cmd_run(unit=unit, do_exec=do_exec)
-    else:
-        return launchd.cmd_run(unit=unit, do_exec=do_exec)
-
-
-def cmd_past(unit: Unit) -> None:
-    if IS_SYSTEMD:
-        return systemd.cmd_past(unit)
-    else:
-        return launchd.cmd_past(unit)
-
-
-# TODO think if it's worth integrating with timers?
-def cmd_monitor(params: MonitorParams) -> None:
-    managed = list(managed_units(with_body=False))  # body slows down this call quite a bit
-    if len(managed) == 0:
-        logger.warning('no managed units!')
-
-    logger.debug('starting monitor...')
-
-    entries = get_entries_for_monitor(managed=managed, params=params)
-    print_monitor(entries)
-
-
 # TODO test it on CI?
+# TODO explicitly inject it into readme?
 def _drontab_example() -> str:
     return '''
 from dron.api import job
@@ -190,193 +63,207 @@ def jobs():
 '''.lstrip()
 
 
-def make_parser() -> argparse.ArgumentParser:
-    from .common import VerifyOff
+def _get_epilog() -> str:
+    return '''
+* Why?
+
+In short, because I want to benefit from the heavy lifting that Systemd does: timeouts, resource management, restart policies, powerful scheduling specs and logging,
+while not having to manually manipulate numerous unit files and restart the daemon all over.
+
+I elaborate on what led me to implement it and motivation [[https://beepb00p.xyz/scheduler.html#what_do_i_want][here]]. Also:
+
+\b
+- why not just use [[https://beepb00p.xyz/scheduler.html#cron][cron]]?
+- why not just use [[https://beepb00p.xyz/scheduler.html#systemd][systemd]]?
+'''.strip()
 
-    def add_verify(p: argparse.ArgumentParser) -> None:
-        # specify in readme???
-        # would be nice to use external checker..
-        # https://github.com/systemd/systemd/issues/8072
-        # https://unix.stackexchange.com/questions/493187/systemd-under-ubuntu-18-04-1-fails-with-failed-to-create-user-slice-serv
-        p.add_argument('--no-verify', action=VerifyOff, nargs=0, help='Skip systemctl verify step')
 
-    p = argparse.ArgumentParser(
-        prog='dron',
-        description='''
+@click.group(
+    context_settings={'show_default': True},
+    help="""
 dron -- simple frontend for Systemd, inspired by cron.
 
+\b
 - *d* stands for 'Systemd'
 - *ron* stands for 'cron'
 
 dron is my attempt to overcome things that make working with Systemd tedious
-'''.lstrip(),
-        formatter_class=lambda prog: argparse.RawTextHelpFormatter(prog, width=100),
-    )
-    # TODO ugh. when you type e.g. 'dron apply', help format is wrong..
-    example = ''.join(': ' + l for l in _drontab_example().splitlines(keepends=True))
-    # TODO begin_src python maybe?
-    p.epilog = f'''
-* What does it do?
-In short, you type ~dron edit~ and edit your config file, similarly to ~crontab -e~:
+""".strip(),
+    epilog=_get_epilog(),
+)
+@click.option(
+    '--marker',
+    required=False,
+    help=f'Use custom marker instead of default `{common.MANAGED_MARKER}`. Useful for developing/testing.',
+)
+def cli(*, marker: str | None) -> None:
+    if marker is not None:
+        common.MANAGED_MARKER = marker
 
-{example}
 
-After you save your changes and exit the editor, your drontab is checked for syntax and applied
+arg_tab_module = click.option(
+    '--module',
+    'tab_module',
+    type=str,
+    default=f'drontab.{socket.gethostname()}',
+)
 
-- if checks have passed, your jobs are mapped onto Systemd units and started up
-- if there are potential errors, you are prompted to fix them before retrying
 
-* Why?
-In short, because I want to benefit from the heavy lifting that Systemd does: timeouts, resource management, restart policies, powerful scheduling specs and logging,
-while not having to manually manipulate numerous unit files and restart the daemon all over.
+# specify in readme???
+# would be nice to use external checker..
+# https://github.com/systemd/systemd/issues/8072
+# https://unix.stackexchange.com/questions/493187/systemd-under-ubuntu-18-04-1-fails-with-failed-to-create-user-slice-serv
+def _set_verify_off(ctx, param, value) -> None:  # noqa: ARG001
+    if value is True:
+        set_verify_off()
 
-I elaborate on what led me to implement it and motivation [[https://beepb00p.xyz/scheduler.html#what_do_i_want][here]]. Also:
 
-- why not just use [[https://beepb00p.xyz/scheduler.html#cron][cron]]?
-- why not just use [[https://beepb00p.xyz/scheduler.html#systemd][systemd]]?
-    '''
+arg_no_verify = click.option(
+    '--no-verify',
+    is_flag=True,
+    callback=_set_verify_off,
+    expose_value=False,
+    help='Skip systemctl verify step',
+)
 
-    p.add_argument(
-        '--marker', required=False, help=f'Use custom marker instead of default `{MANAGED_MARKER}`. Useful for developing/testing.'
-    )
 
-    def add_tabfile_arg(p: argparse.ArgumentParser) -> None:
-        p.add_argument('tabfile', type=Path, nargs='?')
+@cli.command('lint')
+@arg_tab_module
+@arg_no_verify
+def cmd_lint(*, tab_module: str) -> None:
+    # FIXME how to disable verity?
+    # FIXME lint command isn't very interesting now btw?
+    # perhaps instead, either add dry mode to apply
+    # or split into the 'diff' part and side effect apply part
+    _state = do_lint(tab_module)
+    logger.info('all good')
 
-    sp = p.add_subparsers(dest='mode')
 
-    ### actions on drontab file
-    edit_parser = sp.add_parser('edit', help="Edit drontab (like 'crontab -e')")
-    add_verify(edit_parser)
+@cli.command('print')
+@arg_tab_module
+@click.option('--pretty', is_flag=True, help='Pretty print')
+@arg_no_verify
+def cmd_print(*, tab_module: str, pretty: bool) -> None:
+    """Parse and print drontab"""
+    jobs = list(load_jobs(tab_module=tab_module))
 
-    apply_parser = sp.add_parser('apply', help="Apply drontab (like 'crontab' with no args)")
-    add_tabfile_arg(apply_parser)
-    add_verify(apply_parser)
-    # TODO --force?
-    lint_parser = sp.add_parser('lint', help="Check drontab (no 'crontab' alternative, sadly!)")
-    add_tabfile_arg(lint_parser)
-    add_verify(lint_parser)
+    if pretty:
+        import tabulate
 
-    print_parser = sp.add_parser('print', help="Parse and print drontab")
-    add_tabfile_arg(print_parser)
-    print_parser.add_argument('--pretty', action='store_true')
-    ###
+        items = [
+            {
+                'UNIT': job.unit_name,
+                'SCHEDULE': job.when,
+                'COMMAND': escape(job.command),
+            }
+            for job in jobs
+        ]
+        print(tabulate.tabulate(items, headers="keys"))
+    else:
+        for j in jobs:
+            print(j)
 
-    ### actions on managed jobs
-    debug_parser = sp.add_parser('debug', help='Print some debug info')
 
-    uninstall_parser = sp.add_parser('uninstall', help="Uninstall all managed jobs")
-    add_verify(uninstall_parser)
+# TODO --force?
+@cli.command('apply')
+@arg_tab_module
+def cmd_apply(*, tab_module: str) -> None:
+    """Apply drontab (like 'crontab' with no args)"""
+    apply(tab_module)
 
-    run_parser = sp.add_parser('run', help='Run the job right now, ignoring the timer')
-    run_parser.add_argument('unit', type=str, nargs='?')  # TODO add shell completion?
-    run_parser.add_argument('--exec', action='store_true', dest='do_exec', help='Run directly, not via systemd/launchd')
 
-    past_parser = sp.add_parser('past', help='List past job runs')
-    past_parser.add_argument('unit', type=str, nargs='?')  # TODO add shell completion?
-    ###
+@cli.command('debug')
+def cmd_debug() -> None:
+    """Print some debug info"""
+    managed = managed_units(with_body=False)  # TODO not sure about body
+    for x in managed:
+        pprint(x, stream=sys.stderr)
 
-    ### misc actions
-    mp = sp.add_parser('monitor', help='Monitor services/timers managed by dron')
-    mp.add_argument('-n', type=int, default=1, help='refresh every n seconds')
-    mp.add_argument('--once', action='store_true', help='only call once')
-    mp.add_argument('--rate', action='store_true', help='Display success rate (unstable and potentially slow)')
-    mp.add_argument('--command', action='store_true', help='Display command')
-    ###
-    return p
 
+@cli.command('uninstall')
+def cmd_uninstall() -> None:
+    """Remove all managed jobs (will ask for confirmation)"""
+    click.confirm('Going to remove all dron managed jobs. Continue?', default=True, abort=True)
+    manage([])
 
-def main() -> None:
-    from .cli import make_parser
 
-    p = make_parser()
-    args = p.parse_args()
+@cli.group('job')
+def cli_job() -> None:
+    """Actions on individual jobs"""
+    pass
 
-    marker: str | None = args.marker
-    if marker is not None:
-        from . import common
 
-        common.MANAGED_MARKER = marker
+def _prompt_for_unit() -> UnitName:
+    from prompt_toolkit import PromptSession
+    from prompt_toolkit.completion import WordCompleter
 
-    mode: str = args.mode
-
-    def tabfile_or_default() -> Path:
-        tabfile = args.tabfile
-        if tabfile is None:
-            tabfile = DRONTAB
-        return tabfile
-
-    def prompt_for_unit() -> UnitName:
-        from prompt_toolkit import PromptSession
-        from prompt_toolkit.completion import WordCompleter
-
-        # TODO print options
-        managed = list(managed_units(with_body=False))
-        units = [x.unit_file.stem for x in managed]
-
-        print('Units under dron:', file=sys.stderr)
-        for u in units:
-            print(f'- {u}', file=sys.stderr)
-
-        completer = WordCompleter(units, ignore_case=True)
-        session = PromptSession("Select a unit: ", completer=completer)  # type: ignore[var-annotated]
-        selected = session.prompt()
-        return selected
-
-    if mode == 'edit':
-        cmd_edit()
-    elif mode == 'apply':
-        tabfile = tabfile_or_default()
-        cmd_apply(tabfile)
-    elif mode == 'lint':
-        tabfile = tabfile_or_default()
-        cmd_lint(tabfile)
-    elif mode == 'print':
-        tabfile = tabfile_or_default()
-
-        from .cli import cmd_print  # lazy due to circular import
-
-        cmd_print(tabfile=tabfile, pretty=args.pretty)
-    elif mode == 'debug':
-        managed = managed_units(with_body=False)  # TODO not sure about body
-        for x in managed:
-            pprint(x, stream=sys.stderr)
-    elif mode == 'uninstall':
-        click.confirm('Going to remove all dron managed jobs. Continue?', default=True, abort=True)
-        with TemporaryDirectory() as td:
-            empty = Path(td) / 'empty'
-            empty.write_text(
-                '''\
-def jobs():
-    yield from []
-'''
-            )
-            cmd_apply(empty)
-    elif mode == 'run':
-        unit = args.unit if args.unit is not None else prompt_for_unit()
-        do_exec = args.do_exec
-        cmd_run(unit=unit, do_exec=do_exec)
-    elif mode == 'past':
-        unit = args.unit if args.unit is not None else prompt_for_unit()
-        cmd_past(unit=unit)
-    elif mode == 'monitor':
-        once = args.once
-
-        params = MonitorParams(
-            with_success_rate=args.rate,
-            with_command=args.command,
-        )
-
-        if once:
-            # fallback on old style monitor for now?
-            # this can be quite useful for grepping etc..
-            cmd_monitor(params=params)
-        else:
-            from .monitor import MonitorApp
-
-            app = MonitorApp(monitor_params=params, refresh_every=args.n)
-            app.run()
+    # TODO print options
+    managed = list(managed_units(with_body=False))
+    units = [x.unit_file.stem for x in managed]
+
+    print('Units under dron:', file=sys.stderr)
+    for u in units:
+        print(f'- {u}', file=sys.stderr)
+
+    completer = WordCompleter(units, ignore_case=True)
+    session = PromptSession("Select a unit: ", completer=completer)  # type: ignore[var-annotated]
+    selected = session.prompt()
+    return selected
+
+
+arg_unit = click.argument('unit', type=Unit, default=_prompt_for_unit)
+
+
+@cli_job.command('past')
+@arg_unit
+def cmd_past(unit: Unit) -> None:
+    if IS_SYSTEMD:
+        # TODO hmm seems like this just exit with 0 if unit diesn't exist
+        return systemd.cmd_past(unit)
     else:
-        logger.error(f'Unknown mode: {mode}')
-        p.print_usage(sys.stderr)
-        sys.exit(1)
+        return launchd.cmd_past(unit)
+
+
+@cli_job.command('run')
+@arg_unit
+@click.option('--exec', 'do_exec', is_flag=True, help='Run directly, not via systemd/launchd')
+def cmd_run(*, unit: Unit, do_exec: bool) -> None:
+    """Run the job right now, ignoring the timer"""
+    if IS_SYSTEMD:
+        return systemd.cmd_run(unit=unit, do_exec=do_exec)
+    else:
+        return launchd.cmd_run(unit=unit, do_exec=do_exec)
+
+
+@cli.command('monitor')
+@click.option('-n', type=float, default=1.0, help='refresh every n seconds')
+@click.option('--once', is_flag=True, help='only call once')
+@click.option('--rate', is_flag=True, help='Display success rate (unstable and potentially slow)')
+@click.option('--command', is_flag=True, help='Display command')
+def cmd_monitor(*, n: float, once: bool, rate: bool, command: bool) -> None:
+    """Monitor services/timers managed by dron"""
+    params = MonitorParams(
+        with_success_rate=rate,
+        with_command=command,
+    )
+
+    if once:
+        # old style monitor
+        # TODO think if it's worth integrating with timers?
+        managed = list(managed_units(with_body=False))  # body slows down this call quite a bit
+        if len(managed) == 0:
+            logger.warning('no managed units!')
+
+        logger.debug('starting monitor...')
+
+        entries = get_entries_for_monitor(managed=managed, params=params)
+        print_monitor(entries)
+    else:
+        from .monitor import MonitorApp
+
+        app = MonitorApp(monitor_params=params, refresh_every=n)
+        app.run()
+
+
+def main() -> None:
+    cli()

dron/common.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
-import argparse
 import platform
 import shlex
 import sys
+from collections.abc import Iterable, Sequence
 from dataclasses import asdict, dataclass, replace
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, Iterable, Sequence, TypeVar, Union
+from typing import Any
 
 from loguru import logger  # noqa: F401
 
@@ -16,15 +16,15 @@ datetime_naive = datetime
 
 
 # TODO can remove this? although might be useful for tests
-VERIFY_UNITS = True
+VERIFY_UNITS: bool = True
 # TODO ugh. verify tries using already installed unit files so if they were bad, everything would fail
 # I guess could do two stages, i.e. units first, then timers
 # dunno, a bit less atomic though...
 
-class VerifyOff(argparse.Action):
-    def __call__(self, parser, namespace, values, option_string = None):  # noqa: ARG002
-        global VERIFY_UNITS
-        VERIFY_UNITS = False
+
+def set_verify_off() -> None:
+    global VERIFY_UNITS
+    VERIFY_UNITS = False
 
 
 @dataclass
@@ -45,6 +45,11 @@ class UnitState:
     cmdline: Sequence[str] | None  # can be None for timers
 
 
+@dataclass
+class SystemdUnitState(UnitState):
+    dbus_properties: Any  # seems like keeping this around massively speeds up dbus access...
+
+
 @dataclass
 class LaunchdUnitState(UnitState):
     # NOTE: can legit be str (e.g. if unit was never ran before)
@@ -59,44 +64,46 @@ State = Iterable[UnitState]
 IS_SYSTEMD = platform.system() != 'Darwin'  # if not systemd it's launchd
 
 
-
-T = TypeVar('T')
-def unwrap(x: T | None) -> T:
+def unwrap[T](x: T | None) -> T:
     assert x is not None
     return x
 
 
-PathIsh = Union[str, Path]
+PathIsh = str | Path
 
 # if it's an str, assume it's already escaped
 # otherwise we are responsible for escaping..
-Command = Union[PathIsh, Sequence[PathIsh]]
+Command = PathIsh | Sequence[PathIsh]
 
 
 OnCalendar = str
-TimerSpec = Dict[str, str] # meh # TODO why is it a dict???
+TimerSpec = dict[str, str]  # meh # TODO why is it a dict???
 ALWAYS = 'always'
-When = Union[OnCalendar, TimerSpec]
+When = OnCalendar | TimerSpec
+
+
+MANAGED_MARKER: str = '(MANAGED BY DRON)'
 
 
-MANAGED_MARKER = '(MANAGED BY DRON)'
 def is_managed(body: str) -> bool:
     # switching off it because it's unfriendly to launchd
     legacy_marker = '<MANAGED BY DRON>'
     return MANAGED_MARKER in body or legacy_marker in body
 
 
-
 pytest_fixture: Any
 under_pytest = 'pytest' in sys.modules
 if under_pytest:
     import pytest
+
     pytest_fixture = pytest.fixture
 else:
-    pytest_fixture = lambda f: f # no-op otherwise to prevent pytest import
+    pytest_fixture = lambda f: f  # no-op otherwise to prevent pytest import
 
 
 Escaped = str
+
+
 def escape(command: Command) -> Escaped:
     if isinstance(command, Escaped):
         return command
@@ -118,7 +125,6 @@ def test_wrap() -> None:
     assert wrap('cat', bin_) == "cat /bin/bash"
 
 
-
 @dataclass(order=True)
 class MonitorEntry:
     unit: str
@@ -143,8 +149,9 @@ def print_monitor(entries: Iterable[MonitorEntry]) -> None:
         key=lambda e: (e.pid is None, e.status_ok, e),
     )
 
-    import termcolor  # noqa: I001
     import tabulate
+    import termcolor
+
     tabulate.PRESERVE_WHITESPACE = True
 
     headers = [
@@ -170,5 +177,5 @@ def print_monitor(entries: Iterable[MonitorEntry]) -> None:
                 next=termcolor.colored('running', 'yellow'),
                 left='--',
             )
-        items.append(list(asdict(e).values())[:len(headers)])
+        items.append(list(asdict(e).values())[: len(headers)])
     print(tabulate.tabulate(items, headers=headers))