goatbeat-cli 0.1.0__py3-none-any.whl

goatbeat/cli/commands.py

@@ -0,0 +1,183 @@
+import json
+import signal
+import socket
+import sys
+import threading
+import uuid
+from collections.abc import Sequence
+from types import FrameType
+from typing import Final
+
+from goatbeat.cli import environment as runtime
+from goatbeat.cli.environment import Check, Environment
+from goatbeat.core.ids import IdempotencyKey, SchedulerId
+from goatbeat.core.schedule import Schedule
+from goatbeat.core.scheduler import Scheduler
+from goatbeat.core.time import SystemClock
+from goatbeat.core.triggers import CronTrigger
+
+SUCCESS: Final = 0
+CHECK_FAILED: Final = 1
+STOP_SIGNALS: Final = (signal.SIGTERM, signal.SIGINT)
+
+
+class CommandFailedError(Exception):
+    pass
+
+
+def run_scheduler(environment: Environment, *, once: bool, metrics_port: int | None) -> int:
+    environment.ready()
+    metrics = runtime.scheduler_metrics(environment.metrics, metrics_port)
+    scheduler = Scheduler(
+        store=environment.store,
+        leases=environment.leases,
+        submitter=environment.submitter,
+        config=environment.config,
+        registry=environment.registry,
+        metrics=metrics,
+    )
+    if once:
+        try:
+            scheduler.start()
+            scheduler.tick()
+        finally:
+            scheduler.release()
+        return SUCCESS
+    stop = threading.Event()
+
+    def request_stop(signum: int, frame: FrameType | None) -> None:
+        del signum, frame
+        stop.set()
+
+    for stop_signal in STOP_SIGNALS:
+        signal.signal(stop_signal, request_stop)
+    scheduler.run(stop)
+    return SUCCESS
+
+
+def publish(environment: Environment) -> None:
+    """Code-declared schedules must be in the store before anything reads it."""
+    environment.ready()
+    environment.store.sync_code_schedules(environment.registry.definitions(), SystemClock().now())
+
+
+def status(environment: Environment, *, as_json: bool) -> int:
+    publish(environment)
+    now = SystemClock().now()
+    lease = environment.leases.current()
+    schedules = environment.store.list_schedules()
+    wakeup = environment.store.next_wakeup()
+    report: dict[str, object] = {
+        "leader": None
+        if lease is None
+        else {
+            "holder": lease.holder.value,
+            "token": lease.token.value,
+            "expires_at": lease.expires_at.isoformat(),
+            "held": lease.held_at(now),
+        },
+        "schedules": {
+            "total": len(schedules),
+            "enabled": sum(schedule.definition.enabled for schedule in schedules),
+        },
+        "next_wakeup": None if wakeup is None else wakeup.isoformat(),
+    }
+    if as_json:
+        _write(json.dumps(report))
+        return SUCCESS
+    leader = report["leader"]
+    _write(f"leader: {leader if leader is not None else 'none yet'}")
+    _write(f"schedules: {report['schedules']}")
+    _write(f"next wakeup: {report['next_wakeup']}")
+    return SUCCESS
+
+
+def doctor(environment: Environment, *, as_json: bool) -> int:
+    checks = _run_checks(environment)
+    if as_json:
+        _write(json.dumps([_check_dict(check) for check in checks]))
+    else:
+        for check in checks:
+            _write(f"{'ok  ' if check.ok else 'FAIL'} {check.name}: {check.detail}")
+    return SUCCESS if all(check.ok for check in checks) else CHECK_FAILED
+
+
+def list_schedules(environment: Environment, *, as_json: bool) -> int:
+    publish(environment)
+    described = [_describe(schedule) for schedule in environment.store.list_schedules()]
+    if as_json:
+        _write(json.dumps(described))
+        return SUCCESS
+    for item in described:
+        state = "enabled" if item["enabled"] else "disabled"
+        _write(
+            f"{item['name']:<40} {item['source']:<6} {state:<9} "
+            f"{item['next_run_at']:<33} {item['trigger']}"
+        )
+    return SUCCESS
+
+
+def run_now(environment: Environment, name: str) -> int:
+    publish(environment)
+    schedule = environment.store.get_schedule(name)
+    if schedule is None:
+        raise CommandFailedError(f"unknown schedule {name!r}")
+    key = IdempotencyKey(f"manual:{uuid.uuid4().hex}")
+    requester = SchedulerId(f"cli:{socket.gethostname()}")
+    execution = environment.store.request_run(schedule, key, requester, SystemClock().now())
+    _write(f"{execution.idempotency_key.value} {execution.status.value}")
+    return SUCCESS
+
+
+def prune(environment: Environment) -> int:
+    environment.store.sync_code_schedules(
+        environment.registry.definitions(), SystemClock().now(), prune=True
+    )
+    return SUCCESS
+
+
+def migrate(environment: Environment) -> int:
+    _write(environment.migrate() if environment.migrate else "nothing to migrate")
+    return SUCCESS
+
+
+def _run_checks(environment: Environment) -> Sequence[Check]:
+    backend = list(environment.backend_checks())
+    if any(not check.ok for check in backend if check.name == "schema"):
+        return [Check("store", ok=True, detail="reachable"), *backend]
+    publish(environment)
+    schedules = environment.store.list_schedules()
+    checks = [Check("store", ok=True, detail=f"{len(schedules)} schedules readable")]
+    paths = sorted({schedule.definition.task.path for schedule in schedules})
+    missing = [problem for path in paths if (problem := environment.task_problem(path))]
+    checks.append(
+        Check(
+            "tasks",
+            ok=not missing,
+            detail="every task imports" if not missing else "; ".join(missing),
+        )
+    )
+    return [*checks, *backend]
+
+
+def _check_dict(check: Check) -> dict[str, object]:
+    return {"name": check.name, "ok": check.ok, "detail": check.detail}
+
+
+def _describe(schedule: Schedule) -> dict[str, str | bool]:
+    trigger = schedule.definition.trigger
+    if isinstance(trigger, CronTrigger):
+        described = f"cron {trigger.expression.text} ({trigger.timezone.key})"
+    else:
+        described = f"every {trigger.every}"
+    return {
+        "name": schedule.name,
+        "source": schedule.source.value,
+        "enabled": schedule.definition.enabled,
+        "next_run_at": schedule.next_run_at.isoformat(),
+        "trigger": described,
+    }
+
+
+def _write(line: str) -> None:
+    sys.stdout.write(f"{line}\n")

goatbeat/cli/environment.py

@@ -0,0 +1,256 @@
+import os
+from collections.abc import Callable, Generator, Sequence
+from contextlib import ExitStack, contextmanager
+from dataclasses import dataclass
+from datetime import timedelta
+from importlib import import_module
+from importlib.util import find_spec
+from typing import Final
+from urllib.parse import urlsplit
+
+from goatbeat.core.app import GoatbeatApp
+from goatbeat.core.config import GoatbeatConfig
+from goatbeat.core.errors import ConfigurationError
+from goatbeat.core.observability import FanoutMetrics, MetricsSink, NoopMetrics
+from goatbeat.core.protocols import LeaseManager, ScheduleStore, TaskSubmitter
+from goatbeat.core.registry import SupportsDefinitions
+from goatbeat.core.stores.memory import MemoryStore
+from goatbeat.core.stores.sqlite import SQLiteStore
+from goatbeat.core.tasks import import_object
+from goatbeat.core.time import SystemClock
+
+APP_VARIABLE: Final = "GOATBEAT_APP"
+DJANGO_VARIABLE: Final = "DJANGO_SETTINGS_MODULE"
+DATABASE_VARIABLE: Final = "GOATBEAT_DATABASE_URL"
+SQLITE_PREFIX: Final = "sqlite:///"
+# libpq also accepts "host=... dbname=..." strings; they carry no URL scheme.
+LIBPQ_KEYWORDS: Final = "libpq"
+# Lease correctness ignores host clocks; a larger drift still confuses logs and schedules.
+MAX_CLOCK_DRIFT: Final = timedelta(seconds=2)
+PROMETHEUS_HINT: Final = "--metrics-port needs: pip install goatbeat[prometheus]"
+
+
+@dataclass(frozen=True, slots=True)
+class Check:
+    name: str
+    ok: bool
+    detail: str
+
+
+def no_checks() -> Sequence[Check]:
+    return ()
+
+
+def always_ready() -> None:
+    pass
+
+
+def import_problem(path: str) -> str | None:
+    try:
+        import_object(path)
+    except Exception as error:
+        return f"{path}: {type(error).__name__}: {error}"
+    return None
+
+
+@dataclass(slots=True)
+class Environment:
+    config: GoatbeatConfig
+    store: ScheduleStore
+    leases: LeaseManager
+    registry: SupportsDefinitions
+    submitter: TaskSubmitter
+    metrics: MetricsSink
+    backend_checks: Callable[[], Sequence[Check]] = no_checks
+    migrate: Callable[[], str] | None = None
+    task_problem: Callable[[str], str | None] = import_problem
+    ready: Callable[[], None] = always_ready
+
+
+def start_http_server(port: int) -> None:
+    try:
+        from prometheus_client import start_http_server as serve  # noqa: PLC0415
+    except ImportError as error:
+        raise ConfigurationError(PROMETHEUS_HINT) from error
+    serve(port)
+
+
+def scheduler_metrics(configured: MetricsSink, port: int | None) -> MetricsSink:
+    if port is None:
+        return configured
+    try:
+        from goatbeat.prometheus import PrometheusMetrics  # noqa: PLC0415
+    except ImportError as error:
+        raise ConfigurationError(PROMETHEUS_HINT) from error
+    start_http_server(port)
+    if isinstance(configured, PrometheusMetrics):
+        return configured
+    if isinstance(configured, NoopMetrics):
+        return PrometheusMetrics()
+    return FanoutMetrics(configured, PrometheusMetrics())
+
+
+@contextmanager
+def open_environment(app_reference: str | None) -> Generator[Environment]:
+    reference = app_reference or os.environ.get(APP_VARIABLE)
+    with ExitStack() as stack:
+        if reference is None and os.environ.get(DJANGO_VARIABLE):
+            yield _django_environment(stack)
+        elif reference is None:
+            raise ConfigurationError(
+                "tell goatbeat where your schedules are: --app module:attribute, "
+                f"{APP_VARIABLE}, or {DJANGO_VARIABLE} for a Django project"
+            )
+        else:
+            config = GoatbeatConfig.from_env(os.environ)
+            yield _standalone_environment(stack, load_app(reference), config)
+
+
+def load_app(reference: str) -> GoatbeatApp:
+    module_name, _, attribute = reference.partition(":")
+    if not module_name or not attribute:
+        raise ConfigurationError(f"--app expects module:attribute, got {reference!r}")
+    try:
+        module = import_module(module_name)  # nosemgrep: non-literal-import
+        target: object = getattr(module, attribute)
+    except (ImportError, AttributeError) as error:
+        raise ConfigurationError(f"cannot load {reference!r}: {error}") from error
+    if callable(target):
+        target = target()
+    if not isinstance(target, GoatbeatApp):
+        raise ConfigurationError(f"{reference!r} is not a GoatbeatApp")
+    return target
+
+
+def _standalone_environment(
+    stack: ExitStack, app: GoatbeatApp, config: GoatbeatConfig
+) -> Environment:
+    url = config.database_url
+    if url is None:
+        raise ConfigurationError(
+            f"set {DATABASE_VARIABLE} (postgresql://..., {SQLITE_PREFIX}path or memory://)"
+        )
+    scheme = urlsplit(url).scheme or (LIBPQ_KEYWORDS if "=" in url else "")
+    if scheme == "memory":
+        memory = MemoryStore(SystemClock())
+        return _environment(app, config, memory, memory)
+    if scheme == "sqlite":
+        sqlite = SQLiteStore(_sqlite_path(url), SystemClock())
+        stack.callback(sqlite.close)
+        return _environment(app, config, sqlite, sqlite)
+    if scheme in {"postgres", "postgresql", LIBPQ_KEYWORDS}:
+        return _postgres_environment(stack, app, config, url)
+    raise ConfigurationError(f"unsupported database URL scheme {scheme!r}")
+
+
+def _sqlite_path(url: str) -> str:
+    path = url.removeprefix(SQLITE_PREFIX)
+    if not url.startswith(SQLITE_PREFIX) or not path or urlsplit(url).netloc:
+        raise ConfigurationError(
+            f"SQLite URLs look like {SQLITE_PREFIX}relative.db or {SQLITE_PREFIX}/absolute.db, "
+            f"got {url!r}"
+        )
+    return path
+
+
+def _environment(
+    app: GoatbeatApp, config: GoatbeatConfig, store: ScheduleStore, leases: LeaseManager
+) -> Environment:
+    return Environment(
+        config=config,
+        store=store,
+        leases=leases,
+        registry=app.registry,
+        submitter=app.submitter,
+        metrics=app.metrics,
+    )
+
+
+def _postgres_environment(
+    stack: ExitStack, app: GoatbeatApp, config: GoatbeatConfig, url: str
+) -> Environment:
+    try:
+        from goatbeat.postgres.notify import PsycopgNotifier  # noqa: PLC0415
+        from goatbeat.postgres.provider import PsycopgProvider  # noqa: PLC0415
+        from goatbeat.postgres.schema import (  # noqa: PLC0415
+            SCHEMA_VERSION,
+            applied_version,
+            database_clock,
+            migrate,
+        )
+        from goatbeat.postgres.store import PostgresStore  # noqa: PLC0415
+    except ImportError as error:
+        raise ConfigurationError("PostgreSQL needs: pip install goatbeat[postgres]") from error
+    provider = stack.enter_context(PsycopgProvider.connect(url, wait=True))
+    notifier = stack.enter_context(PsycopgNotifier(url))
+    store = PostgresStore(provider, notifier=notifier)
+
+    def schema_problem() -> str | None:
+        version = applied_version(provider)
+        if version < SCHEMA_VERSION:
+            return f"schema at version {version}, expected {SCHEMA_VERSION}: run goatbeat migrate"
+        if version > SCHEMA_VERSION:
+            return f"schema at version {version} is newer than this release: upgrade goatbeat"
+        return None
+
+    def ready() -> None:
+        problem = schema_problem()
+        if problem is not None:
+            raise ConfigurationError(problem)
+
+    def checks() -> Sequence[Check]:
+        problem = schema_problem()
+        drift = database_clock(provider) - SystemClock().now()
+        return (
+            Check("schema", problem is None, problem or f"at version {SCHEMA_VERSION}"),
+            Check(
+                "clock",
+                abs(drift) <= MAX_CLOCK_DRIFT,
+                f"local clock is {drift.total_seconds():+.3f} s from PostgreSQL",
+            ),
+        )
+
+    def apply_migrations() -> str:
+        return f"schema at version {migrate(provider)}"
+
+    environment = _environment(app, config, store, store)
+    environment.backend_checks = checks
+    environment.migrate = apply_migrations
+    environment.ready = ready
+    return environment
+
+
+def _django_environment(stack: ExitStack) -> Environment:
+    try:
+        import django  # noqa: PLC0415
+        from django.core.exceptions import ImproperlyConfigured  # noqa: PLC0415
+
+        from goatbeat.django import registry  # noqa: PLC0415
+        from goatbeat.django.conf import DjangoSettings  # noqa: PLC0415
+        from goatbeat.django.provider import DjangoProvider, notifier_conninfo  # noqa: PLC0415
+        from goatbeat.django.submitter import DjangoTasksSubmitter, is_django_task  # noqa: PLC0415
+        from goatbeat.postgres.notify import PsycopgNotifier  # noqa: PLC0415
+        from goatbeat.postgres.store import PostgresStore  # noqa: PLC0415
+    except ImportError as error:
+        raise ConfigurationError("Django projects need: pip install goatbeat[django]") from error
+    module = os.environ.get(DJANGO_VARIABLE, "")
+    try:
+        if find_spec(module) is None:
+            raise ImportError(f"no module named {module!r}")
+        django.setup()
+    except (ImportError, ImproperlyConfigured) as error:
+        raise ConfigurationError(f"cannot load the Django settings {module!r}: {error}") from error
+    settings = DjangoSettings.from_django()
+    notifier = stack.enter_context(PsycopgNotifier(notifier_conninfo(settings.database)))
+    store = PostgresStore(DjangoProvider(settings.database), notifier=notifier)
+    environment = Environment(
+        config=settings.config,
+        store=store,
+        leases=store,
+        registry=registry(),
+        submitter=DjangoTasksSubmitter(),
+        metrics=NoopMetrics(),
+        task_problem=lambda path: None if is_django_task(path) else f"{path}: not a Django task",
+    )
+    environment.migrate = lambda: "Django projects migrate with: python manage.py migrate"
+    return environment

goatbeat/cli/logs.py

@@ -0,0 +1,47 @@
+import logging
+import sys
+from typing import Final, override
+
+from goatbeat.core.observability import EXTRA_KEY, LOGGER_NAME, JsonFormatter
+
+DATABASE_MODULES: Final = ("psycopg", "django.db")
+
+
+class TextFormatter(logging.Formatter):
+    @override
+    def format(self, record: logging.LogRecord) -> str:
+        line = super().format(record)
+        fields: object = record.__dict__.get(EXTRA_KEY)
+        if isinstance(fields, dict):
+            extra = " ".join(
+                f"{key}={value}"
+                for key, value in fields.items()  # pyright: ignore[reportUnknownVariableType]
+                if key != "event"
+            )
+            line = f"{line} {extra}" if extra else line
+        return line
+
+
+def configure_logging(level: str, *, as_json: bool) -> None:
+    logger = logging.getLogger(LOGGER_NAME)
+    for handler in list(logger.handlers):
+        if getattr(handler, "goatbeat_cli", False):
+            logger.removeHandler(handler)
+    handler = logging.StreamHandler(sys.stderr)
+    handler.goatbeat_cli = True  # type: ignore[attr-defined]
+    handler.setFormatter(
+        JsonFormatter() if as_json else TextFormatter("%(asctime)s %(levelname)s %(message)s")
+    )
+    logger.addHandler(handler)
+    logger.setLevel(level)
+
+
+def is_database_unavailable(error: Exception) -> bool:
+    """psycopg is optional here, so its connection errors are recognized without importing it."""
+    for kind in type(error).__mro__:
+        if (
+            kind.__module__.startswith(("psycopg", "django.db"))
+            and kind.__name__ == "OperationalError"
+        ):
+            return True
+    return False

goatbeat/cli/main.py

@@ -0,0 +1,112 @@
+import argparse
+import sys
+from collections.abc import Callable, Sequence
+from typing import Final
+
+from goatbeat.cli import commands
+from goatbeat.cli.environment import Environment, open_environment
+from goatbeat.cli.logs import configure_logging, is_database_unavailable
+from goatbeat.core.errors import ConfigurationError, StoreUnavailableError
+
+CONFIGURATION_ERROR: Final = 3
+STORE_UNAVAILABLE: Final = 4
+UNEXPECTED_ERROR: Final = 5
+LOG_LEVELS: Final = ("DEBUG", "INFO", "WARNING", "ERROR")
+
+type Handler = Callable[[Environment, argparse.Namespace], int]
+
+
+def parser() -> argparse.ArgumentParser:
+    root = argparse.ArgumentParser(prog="goatbeat", description=__doc__)
+    root.add_argument("--app", help="module:attribute of a GoatbeatApp (or GOATBEAT_APP)")
+    root.add_argument("--log-level", choices=LOG_LEVELS, default="INFO")
+    root.add_argument("--log-format", choices=("text", "json"), default="text")
+    sub = root.add_subparsers(dest="command", required=True)
+
+    scheduler = sub.add_parser("scheduler", help="run the scheduler until SIGTERM")
+    scheduler.add_argument("--once", action="store_true", help="run one tick and exit")
+    scheduler.add_argument("--metrics-port", type=int, help="serve Prometheus metrics")
+    scheduler.set_defaults(handler=_scheduler)
+
+    status = sub.add_parser("status", help="show the leader and schedules")
+    status.add_argument("--json", action="store_true", help="machine-readable output")
+    status.set_defaults(handler=_status)
+
+    doctor = sub.add_parser("doctor", help="check the setup")
+    doctor.add_argument("--json", action="store_true", help="machine-readable output")
+    doctor.set_defaults(handler=_doctor)
+
+    migrate = sub.add_parser("migrate", help="create or upgrade the database schema")
+    migrate.set_defaults(handler=_migrate)
+
+    schedule = sub.add_parser("schedule", help="inspect and manage schedules")
+    actions = schedule.add_subparsers(dest="action", required=True)
+    listing = actions.add_parser("list", help="publish code schedules and list them")
+    listing.add_argument("--json", action="store_true", help="machine-readable output")
+    listing.set_defaults(handler=_list)
+    run = actions.add_parser("run", help="ask the leader to run a schedule now")
+    run.add_argument("name")
+    run.set_defaults(handler=_run)
+    prune = actions.add_parser("prune", help="disable code schedules no longer declared")
+    prune.set_defaults(handler=_prune)
+    return root
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = parser().parse_args(argv)
+    handler: Handler = arguments.handler
+    configure_logging(arguments.log_level, as_json=arguments.log_format == "json")
+    try:
+        with open_environment(arguments.app) as environment:
+            return handler(environment, arguments)
+    except ConfigurationError as error:
+        sys.stderr.write(f"goatbeat: configuration error: {error}\n")
+        return CONFIGURATION_ERROR
+    except StoreUnavailableError as error:
+        sys.stderr.write(f"goatbeat: store unavailable: {error}\n")
+        return STORE_UNAVAILABLE
+    except commands.CommandFailedError as error:
+        sys.stderr.write(f"goatbeat: {error}\n")
+        return commands.CHECK_FAILED
+    except Exception as error:
+        if is_database_unavailable(error):
+            sys.stderr.write(f"goatbeat: store unavailable: {error}\n")
+            return STORE_UNAVAILABLE
+        sys.stderr.write(f"goatbeat: unexpected error: {type(error).__name__}: {error}\n")
+        return UNEXPECTED_ERROR
+
+
+def _scheduler(environment: Environment, arguments: argparse.Namespace) -> int:
+    return commands.run_scheduler(
+        environment, once=arguments.once, metrics_port=arguments.metrics_port
+    )
+
+
+def _status(environment: Environment, arguments: argparse.Namespace) -> int:
+    return commands.status(environment, as_json=bool(arguments.json))
+
+
+def _doctor(environment: Environment, arguments: argparse.Namespace) -> int:
+    return commands.doctor(environment, as_json=bool(arguments.json))
+
+
+def _migrate(environment: Environment, arguments: argparse.Namespace) -> int:
+    del arguments
+    return commands.migrate(environment)
+
+
+def _list(environment: Environment, arguments: argparse.Namespace) -> int:
+    return commands.list_schedules(environment, as_json=bool(arguments.json))
+
+
+def _run(environment: Environment, arguments: argparse.Namespace) -> int:
+    return commands.run_now(environment, str(arguments.name))
+
+
+def _prune(environment: Environment, arguments: argparse.Namespace) -> int:
+    del arguments
+    return commands.prune(environment)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

goatbeat_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: goatbeat-cli
+Version: 0.1.0
+Summary: The goatbeat command line.
+Keywords: scheduler,cron,periodic-tasks,distributed,django-tasks,leader-election
+Author: Louis Midson LAJEANTY
+Author-email: Louis Midson LAJEANTY <midsonlajeanty@proton.me>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: System :: Distributed Computing
+Classifier: Typing :: Typed
+Requires-Dist: goatbeat-core==0.1.0
+Requires-Python: >=3.13
+Project-URL: Homepage, https://github.com/goatlabshq/goatbeat
+Project-URL: Documentation, https://goatlabshq.github.io/goatbeat/
+Project-URL: Issues, https://github.com/goatlabshq/goatbeat/issues
+Description-Content-Type: text/markdown
+
+# goatbeat-cli
+
+The `goatbeat` command line: run the scheduler, inspect status and manage schedules. Part of [Goatbeat](https://github.com/goatlabshq/goatbeat).

goatbeat_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+goatbeat/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+goatbeat/cli/commands.py,sha256=fGC8pSVtpgxEpGijn6_Qofu272mrQ2-sk5Qoi5mrt_Q,6110
+goatbeat/cli/environment.py,sha256=BtMysRc5ZMUU40zHkHvz1Yq7d_fdRLOG2kwmQHmRD1E,9763
+goatbeat/cli/logs.py,sha256=5J2JnDp11Zql3iKv003ZHcAM4qA-xuRy__9KFNhcYlk,1629
+goatbeat/cli/main.py,sha256=NA4XCq4NNVGOD9jKAadoC1E3HWG4TiQolRQpHhnp2Uc,4663
+goatbeat/cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+goatbeat_cli-0.1.0.dist-info/licenses/LICENSE,sha256=Zcs5rp01UDASfBq28ErEU7tdk14P5WTR3zNmlaZKnkA,1105
+goatbeat_cli-0.1.0.dist-info/WHEEL,sha256=oBPtwmRtX9fzUVIGqTf2NA4uW8MUj4N1HrmGwtPkDyA,80
+goatbeat_cli-0.1.0.dist-info/entry_points.txt,sha256=8aiWREFaiqegZ_H_imAz5IzEvf0DUjdbyyHnWDpvG5c,53
+goatbeat_cli-0.1.0.dist-info/METADATA,sha256=QNkLohgobgT__50dU07eXn90bH-_Nw2oUkocp7ClsfA,1089
+goatbeat_cli-0.1.0.dist-info/RECORD,,

goatbeat_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.13.2
+Root-Is-Purelib: true
+Tag: py3-none-any

goatbeat_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+goatbeat = goatbeat.cli.main:main
+

goatbeat_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Louis Midson LAJEANTY <midsonlajeanty@proton.me>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.