git-goose 0.0.1__py3-none-any.whl

git_goose-0.0.1.dist-info/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Anton Agestam
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

git_goose-0.0.1.dist-info/METADATA

@@ -0,0 +1,235 @@
+Metadata-Version: 2.1
+Name: git-goose
+Version: 0.0.1
+Summary: A picky and eager Git hook runner.
+Author-email: Anton Agestam <git@antonagestam.se>
+License: BSD 3-Clause
+Project-URL: Source Repository, https://github.com/antonagestam/goose
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: <3.13,>3.12
+Description-Content-Type: text/markdown; charset=UTF-8
+License-File: LICENSE
+Requires-Dist: pydantic
+Requires-Dist: PyYAML
+Requires-Dist: nodeenv
+Requires-Dist: identify
+Requires-Dist: typer
+Requires-Dist: rich
+Requires-Dist: shellingham
+
+<!-- prettier-ignore-start -->
+<!-- https://github.com/prettier/prettier/issues/15479 -->
+
+> [!NOTE]
+> This project is in its infancy. Please try it out and report and help fix any issues or missing features, but expect a somewhat broken experience.
+>
+> Breaking CLI changes is to be expected without notice between arbitrary versions until version 1.0 is released.
+
+<!-- prettier-ignore-end -->
+
+<h1 align=center>goose<br>🦆🧪💻</h1>
+
+<p align=center>A <i>picky</i> and <i>eager</i> <a href=https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks>Git hook</a> runner.</p>
+
+- Reproducible builds.
+- Dynamic parallelism.
+- Small file-system footprint.
+
+### Features
+
+- Smart parallelism schedules hooks across CPUs while avoiding concurrent writes.
+- Deterministic environments by using ecosystem-specific lock files.
+- Environments are shared across hooks.
+- Self-contained definitions means there's no need to push tool-specific configuration
+  upstream, or to maintain brittle mirroring schemes.
+
+### Parallelism
+
+Goose takes care to keep your CPUs as busy as possible, optimizing to have the full
+suite of hooks finish as soon as possible. It does this by distributing units of work to
+all available processing cores.
+
+Parameterized hooks, or hooks that take files as command line arguments, are divided to
+one unit of work per available core. Whenever a core becomes available for more work, a
+new unit is chosen for execution.
+
+The scheduler takes care to never run more than one mutating hook on the same file. It
+does this by taking into account hooks marked as `read_only` and by comparing sets of
+files a unit of work is assigned to. Two incompatible hooks can be simultaneously
+working on two separate parts of the code-base.
+
+### Deterministic environments
+
+Goose uses lock files to facilitate deterministic results across developer environments
+and CI. You specify dependencies in `goose.yaml`, and invoking `goose run` will produce
+the appropriate lock files under a `.goose/` directory. The `.goose/` directory is meant
+to be checked into git, so that future invocations of `goose run` can use the lock files
+it contains to produce identical environments for hooks to run in.
+
+## Usage
+
+Create a `goose.yaml` file in the repository root.
+
+```yaml
+environments:
+  - id: python
+    ecosystem:
+      language: python
+      version: "3.12"
+    dependencies:
+      - ruff
+
+hooks:
+  - id: ruff
+    environment: python
+    command: ruff
+    args: [check, --force-exclude, --fix]
+    types: [python]
+
+  - id: ruff-format
+    environment: python
+    command: ruff
+    args: [format, --force-exclude]
+    types: [python]
+```
+
+Bootstrap environments, generate lock files, and install dependencies.
+
+```sh
+$ python -m goose upgrade
+```
+
+Run all hooks over all files.
+
+```sh
+$ python -m goose run --select=all
+```
+
+Commit configuration and lock files.
+
+```sh
+$ git add goose.yaml .goose
+$ git commit -m 'Add goose configuration'
+```
+
+### Upgrading hook versions
+
+As pinning of hook versions is handled with lock files, there's no need to change
+configuration to upgrade hook dependency versions, instead you just run the upgrade
+command.
+
+```sh
+$ python -m goose upgrade
+$ git add .goose
+$ git commit -m 'Bump goose dependencies'
+```
+
+### Example node hook
+
+Goose currently supports Python and Node environments, here's an example using
+[Prettier] to format Markdown files.
+
+[Prettier]: https://prettier.io/
+
+```yaml
+environments:
+  - id: node
+    ecosystem:
+      language: node
+      version: "21.7.1"
+    dependencies:
+      - prettier
+
+hooks:
+  - id: prettier
+    environment: node
+    command: prettier
+    types: [markdown]
+    args:
+      - --write
+      - --ignore-unknown
+      - --parser=markdown
+      - --print-width=88
+      - --prose-wrap=always
+```
+
+### Read-only hooks
+
+You will likely want to use a mix of pure linters, as well as formatters and
+auto-fixers. Tools that don't mutate files can be more heavily parallelized by Goose,
+because they can inspect overlapping sets of files simultaneously as other tools. To
+enable this you set `read_only: true` in hook configuration.
+
+```yaml
+environments:
+  - id: python
+    ecosystem:
+      language: python
+      version: "3.12"
+    dependencies:
+      - pre-commit-hooks
+
+hooks:
+  - id: check-case-conflict
+    environment: python
+    command: check-case-conflict
+    read_only: true
+
+  - id: check-merge-conflict
+    environment: python
+    command: check-merge-conflict
+    read_only: true
+    types: [text]
+
+  - id: python-debug-statements
+    environment: python
+    command: debug-statement-hook
+    read_only: true
+    types: [python]
+
+  - id: detect-private-key
+    environment: python
+    command: detect-private-key
+    read_only: true
+    types: [text]
+
+  - id: end-of-file-fixer
+    environment: python
+    command: end-of-file-fixer
+    types: [text]
+
+  - id: trailing-whitespace-fixer
+    environment: python
+    command: trailing-whitespace-fixer
+    types: [text]
+```
+
+Hooks that do not specify `read_only: true` will never run simultaneously as other tools
+over the same file.
+
+### Non-parameterized hooks
+
+Some tools don't support passing files, or just work better if given the responsibility
+to parallelize work itself. One such tool is mypy. You can instruct goose to not pass
+filenames to a hook (and as a consequence, also not spawn multiple parallel jobs for
+this hook).
+
+```yaml
+environments:
+  - id: mypy
+    ecosystem:
+      language: python
+      version: "3.12"
+    dependencies:
+      - mypy
+
+hooks:
+  - id: mypy
+    environment: mypy
+    command: mypy
+    read_only: true
+    parameterize: false
+```

git_goose-0.0.1.dist-info/RECORD

@@ -0,0 +1,30 @@
+goose/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+goose/__main__.py,sha256=k-FvWXMtgVJy8P8y-ZZLmZwX_fVWHqepDaMs3V5pePI,7050
+goose/asyncio.py,sha256=bOhXmv7yaGqoqMGiBB0-HH3XcXfBZPQ28dObnafLJ0U,444
+goose/config.py,sha256=O44J4w6bfA1KH8hxZlu_BudgTCH6EWk9-b5cxaZmc0g,2023
+goose/context.py,sha256=GHTGkCyTrkL2v05ch7X3n12msSH-hvoIO0QP-lLQzMg,983
+goose/environment.py,sha256=rckXiaUaM1KGdAHF3RwyAUJ1CsbYQKe0aO5ExJgcSN8,8182
+goose/executable_unit.py,sha256=K1_GlBpCFOgQqrbmawe6gHkADUpKyMwARp_qbkF0YKM,241
+goose/filter.py,sha256=HHpRGeA8dlZWX4Y-Xm0JtmWWCvVU7YTurlOnf-Ur5Jg,252
+goose/manifest.py,sha256=yYwMqUwM7z8OdjT7Mm5grsfq-FBZRGxzggahL7fGqFo,4613
+goose/orphan_environments.py,sha256=XQ1KhzTFqsrobamjgk4aoe_GpF53aKUVQD8yoamHC7U,638
+goose/parallel.py,sha256=CDVpVU4YFJqsJEDQ2W36B7MvU4LcUcaTtioUuiFuMDw,1212
+goose/paths.py,sha256=skxJJ1r2QZjA64q_X1A73z24SSftw-5ciXmwFYMnlUg,580
+goose/process.py,sha256=HKc--KzGP-i61vzDwJz-vAeSH1kw2aeDVyGZXZJH2FQ,735
+goose/scheduler.py,sha256=-z1qmMlp9xhGZgQBccKbWp6ylOBJP8US-L_1si6f5Gc,5268
+goose/targets.py,sha256=Cji6Faah9psmBnyWnBf9o9giEhBjVHht1ZkAtp6NqU8,2692
+goose/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+goose/_utils/pydantic.py,sha256=mkTODVaAT2XxcG7-GpERbDTBU6q2G2_IRS86Gj2ueNk,139
+goose/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+goose/backend/base.py,sha256=-MH6aj9M4oRQuAQ88n0KeUWjQ0HCbSVJQiVUrTkq12c,1546
+goose/backend/index.py,sha256=E7S8qm-rw_PlUATzGp_ZoqvHOuNS6WrZVTBzMkbSiK0,442
+goose/backend/node.py,sha256=B9vKfbOrFZG5R5EyrfwuGoD7LLlqo2A4wFoxyNhuM3g,5166
+goose/backend/python.py,sha256=bJvMjfsIbsrm7M9YHbkeTMqYzTpQ2BN4gpbhOrs7JeI,5087
+goose/git/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+goose/git/shared.py,sha256=OzpGVKnigWdIuHghj31Vdno-8gEMpScnb1TSxpzGfjs,1238
+goose/git/status.py,sha256=T-TAzmDm0vY6WOfpNY8CCmttI2aEmroHsZLQ9gunYLY,4254
+git_goose-0.0.1.dist-info/LICENSE,sha256=TI5yLazmd6njfFDJi4xrvKB71AjMuNSXLZrrZ112hn0,1521
+git_goose-0.0.1.dist-info/METADATA,sha256=jQM293oOk5zMl3qSuzWxZ_yZFYctWhV5NSdFnHm3XoU,6280
+git_goose-0.0.1.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
+git_goose-0.0.1.dist-info/top_level.txt,sha256=H7wC3j2XnCev-Pw5Zx1OB1QaR1u0kxIEmhfgWu7VcCE,6
+git_goose-0.0.1.dist-info/RECORD,,

git_goose-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (70.3.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

git_goose-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+goose

goose/__main__.py

@@ -0,0 +1,251 @@
+import asyncio
+import enum
+import sys
+import time
+from collections.abc import Collection
+from collections.abc import Iterator
+from pathlib import Path
+from typing import Annotated
+from typing import Final
+from typing import Optional
+from typing import TypeAlias
+from typing import assert_never
+
+import typer
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+from rich.spinner import Spinner
+from rich.table import Table
+from rich.text import Text
+
+from goose.backend.base import RunResult
+from goose.config import HookConfig
+
+from .asyncio import asyncio_entrypoint
+from .context import gather_context
+from .environment import NeedsFreeze
+from .environment import prepare_environment
+from .orphan_environments import probe_orphan_environments
+from .scheduler import Scheduler
+from .scheduler import UnitFinished
+from .scheduler import UnitScheduled
+from .targets import Selector
+from .targets import get_targets
+
+ConfigOption: TypeAlias = Annotated[
+    Path,
+    typer.Option(
+        "--config",
+        resolve_path=True,
+        readable=True,
+        exists=True,
+        dir_okay=False,
+    ),
+]
+default_config: Final = Path("goose.yaml")
+
+
+cli = typer.Typer(pretty_exceptions_enable=False)
+
+
+@cli.command()
+@asyncio_entrypoint
+async def upgrade(
+    config_path: ConfigOption = default_config,
+) -> None:
+    ctx = gather_context(config_path)
+    await asyncio.gather(
+        *[
+            asyncio.create_task(prepare_environment(environment, upgrade=True))
+            for environment in ctx.environments.values()
+        ]
+    )
+    print("All environments up-to-date", file=sys.stderr)
+
+
+def format_unit_state(
+    state: RunResult | asyncio.Task[RunResult] | None,
+    spinner: Table,
+) -> Text | Table:
+    match state:
+        case None:
+            return Text("[ ]", style="dim")
+        case asyncio.Task():
+            return spinner
+        case RunResult.ok:
+            return Text("[✓]", style="green")
+        case RunResult.error:
+            return Text("[✗]", style="red")
+        case RunResult.modified:
+            return Text("[✎]", style="red")
+        case no_match:
+            assert_never(no_match)
+
+
+def format_hook_name(
+    hook: HookConfig,
+    states: Collection[RunResult | asyncio.Task[RunResult] | None],
+) -> Text:
+    if RunResult.error in states:
+        return Text(hook.id, style="red")
+    if any(isinstance(state, asyncio.Task) for state in states):
+        return Text(hook.id)
+    if RunResult.ok in states:
+        return Text(hook.id, style="green")
+    return Text(hook.id, style="dim")
+
+
+def generate_live_process_table(scheduler: Scheduler) -> Iterator[Panel]:
+    spinner = Table.grid()
+    spinner.add_row(
+        "[blue][[/blue]",
+        Spinner("dots4", style="blue"),
+        "[blue]][/blue]",
+    )
+
+    while True:
+        hooks_table = Table(
+            show_header=False,
+            show_edge=False,
+        )
+        hooks_table.add_column("Hook")
+        hooks_table.add_column("Processes")
+        for hook, hook_units in scheduler.state().items():
+            process_table = Table.grid(padding=2)
+            process_table.add_row(
+                *(
+                    format_unit_state(unit_state, spinner)
+                    for unit, unit_state in hook_units.items()
+                )
+            )
+            hooks_table.add_row(
+                format_hook_name(hook, hook_units.values()),
+                process_table,
+            )
+        yield Panel(
+            hooks_table,
+            title="Running hooks",
+            border_style="magenta",
+        )
+
+
+async def display_live_table(scheduler: Scheduler) -> None:
+    live_table = generate_live_process_table(scheduler)
+
+    with Live(refresh_per_second=10) as live:
+        live.update(next(live_table), refresh=True)
+        async for _ in scheduler.until_complete():
+            live.update(next(live_table), refresh=True)
+
+
+def print_summary(console: Console, scheduler: Scheduler) -> None:
+    any_error = False
+    any_modified = False
+    for units in scheduler.state().values():
+        for unit_state in units.values():
+            if unit_state is RunResult.error:
+                any_error = True
+            elif unit_state is RunResult.modified:
+                any_modified = True
+        if any_error and any_modified:
+            break
+
+    if any_error:
+        console.print("Some hooks errored.", style="red")
+    if any_modified:
+        console.print("Some hooks made changes.", style="red")
+    if any_error or any_modified:
+        sys.exit(1)
+
+    console.print("All ok!", style="green")
+
+
+@cli.command()
+@asyncio_entrypoint
+async def run(
+    selected_hook: Optional[str] = typer.Argument(default=None),  # noqa
+    config_path: ConfigOption = default_config,
+    delete_orphan_environments: bool = False,
+    select: Selector = typer.Option(default="diff"),
+) -> None:
+    console = Console(stderr=True)
+    ctx = gather_context(config_path)
+
+    probe_orphan_environments(ctx, delete=delete_orphan_environments)
+
+    prepare_tasks = [
+        asyncio.create_task(prepare_environment(environment))
+        for environment in ctx.environments.values()
+    ]
+    done, pending = await asyncio.wait(
+        prepare_tasks,
+        return_when=asyncio.FIRST_EXCEPTION,
+    )
+    for task in done:
+        try:
+            task.result()
+        except NeedsFreeze:
+            console.print(
+                "Missing lock files, run `goose upgrade` first.",
+                style="red",
+            )
+            sys.exit(1)
+
+    print("All environments ready", file=sys.stderr)
+
+    scheduler = Scheduler(
+        context=ctx,
+        targets=await get_targets(ctx.config, select),
+        selected_hook=selected_hook,
+    )
+
+    if sys.stdout.isatty():
+        await display_live_table(scheduler)
+    else:
+        async for event in scheduler.until_complete():
+            t = time.time_ns()
+            if isinstance(event, UnitScheduled):
+                print(
+                    f"[{event.unit.hook.id}@{event.unit.id}] [{t}] Unit scheduled",
+                    file=sys.stderr,
+                )
+            elif isinstance(event, UnitFinished):
+                print(
+                    f"[{event.unit.hook.id}@{event.unit.id}] [{t}] Unit finished: {event.result.name}",
+                    file=sys.stderr,
+                )
+            else:
+                assert_never(event)
+
+    print_summary(console, scheduler)
+
+
+template = """\
+#!/usr/bin/env bash
+set -euo pipefail
+python -m goose run '--config={config_path}'
+"""
+
+
+class GitHookType(enum.Enum):
+    pre_commit = "pre-commit"
+    pre_push = "pre-push"
+
+
+@cli.command()
+@asyncio_entrypoint
+async def git_hook(
+    hook: GitHookType,
+    config_path: ConfigOption = default_config,
+) -> None:
+    hooks_path = Path(".git/hooks")
+    assert hooks_path.exists()
+    assert hooks_path.is_dir()
+    hook_path = hooks_path / hook.value
+    hook_path.write_text(template.format(config_path=str(config_path)))
+    hook_path.chmod(0o755)
+
+
+if __name__ == "__main__":
+    cli()

goose/_utils/pydantic.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+import pydantic
+
+
+class BaseModel(
+    pydantic.BaseModel,
+    frozen=True,
+    extra="forbid",
+): ...

goose/asyncio.py

@@ -0,0 +1,19 @@
+import asyncio
+import functools
+from collections.abc import Callable
+from collections.abc import Coroutine
+from typing import ParamSpec
+from typing import TypeVar
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def asyncio_entrypoint(
+    fn: Callable[P, Coroutine[None, None, R]],
+) -> Callable[P, R]:
+    @functools.wraps(fn)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        return asyncio.run(fn(*args, **kwargs))
+
+    return wrapper

goose/backend/base.py

@@ -0,0 +1,76 @@
+import enum
+from collections.abc import Awaitable
+from collections.abc import Coroutine
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Protocol
+from typing import final
+
+from goose.config import EnvironmentConfig
+from goose.executable_unit import ExecutableUnit
+
+
+class Bootstrap(Protocol):
+    def __call__(
+        self,
+        *,
+        config: EnvironmentConfig,
+        env_path: Path,
+    ) -> Awaitable[None]: ...
+
+
+class Freeze(Protocol):
+    def __call__(
+        self,
+        *,
+        config: EnvironmentConfig,
+        env_path: Path,
+        lock_files_path: Path,
+    ) -> Awaitable[None]: ...
+
+
+class Sync(Protocol):
+    def __call__(
+        self,
+        *,
+        config: EnvironmentConfig,
+        env_path: Path,
+        lock_files_path: Path,
+    ) -> Awaitable[None]: ...
+
+
+class RunResult(enum.Enum):
+    ok = enum.auto()
+    error = enum.auto()
+    modified = enum.auto()
+
+
+class Run(Protocol):
+    def __call__(
+        self,
+        *,
+        config: EnvironmentConfig,
+        env_path: Path,
+        unit: ExecutableUnit,
+    ) -> Coroutine[None, None, RunResult]: ...
+
+
+@final
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Backend:
+    ecosystem: str
+    bootstrap: Bootstrap
+    """
+    - Create environment if it does not exist.
+    - Install basic dependencies to enable freezing.
+    """
+    freeze: Freeze
+    """
+    - Update lock file.
+    """
+    sync: Sync
+    """
+    - Install missing dependencies.
+    - Uninstall obsolete dependencies.
+    """
+    run: Run

goose/backend/index.py

@@ -0,0 +1,20 @@
+from collections.abc import Mapping
+from types import MappingProxyType
+from typing import Final
+
+from goose.config import EcosystemConfig
+
+from . import node
+from . import python
+from .base import Backend
+
+backends: Final[Mapping[str, Backend]] = MappingProxyType(
+    {
+        "node": node.backend,
+        "python": python.backend,
+    }
+)
+
+
+def load_backend(ecosystem: EcosystemConfig) -> Backend:
+    return backends[ecosystem.language]