git-goose 0.0.1__py3-none-any.whl

goose/backend/node.py

@@ -0,0 +1,190 @@
+import asyncio
+import asyncio.subprocess
+import contextlib
+import os
+import shutil
+import sys
+from collections.abc import Iterator
+from collections.abc import Mapping
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Final
+
+from pydantic import Field
+
+from goose._utils.pydantic import BaseModel
+from goose.config import EnvironmentConfig
+from goose.executable_unit import ExecutableUnit
+from goose.manifest import build_manifest
+from goose.manifest import write_manifest
+from goose.process import stream_both
+from goose.process import system_python
+
+from .base import Backend
+from .base import RunResult
+
+
+class PackageJson(BaseModel):
+    lockfile_version: int = Field(default=3, serialization_alias="lockfileVersion")
+    dependencies: Mapping[str, str]
+
+
+def _bootstrap_env() -> dict[str, str]:
+    return os.environ | {
+        "PYTHONUNBUFFERED": "1",
+    }
+
+
+async def _create_node_env(env_path: Path, version: str) -> None:
+    process = await asyncio.create_subprocess_exec(
+        system_python(),
+        *(
+            "-m",
+            "nodeenv",
+            f"--node={version}",
+            str(env_path),
+        ),
+        env=_bootstrap_env(),
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    await stream_both(process)
+    await process.wait()
+    if process.returncode != 0:
+        raise RuntimeError("Failed creating virtualenv {process.returncode=}")
+
+
+async def bootstrap(
+    env_path: Path,
+    config: EnvironmentConfig,
+) -> None:
+    print(f"Creating node env at {env_path.name}", file=sys.stderr)
+    await _create_node_env(env_path, config.ecosystem.version)
+
+
+def _write_package_json(
+    config: EnvironmentConfig,
+    lock_files_path: Path,
+) -> Path:
+    package_json_path = lock_files_path / "package.json"
+    package_json = PackageJson(
+        dependencies={
+            # todo: support version specs
+            dependency: "*"
+            for dependency in config.dependencies
+        }
+    )
+    package_json_path.write_text(package_json.model_dump_json(by_alias=True))
+    return package_json_path
+
+
+@contextlib.contextmanager
+def cd_to(path: Path) -> Iterator[None]:
+    cd = os.getcwd()
+    try:
+        os.chdir(path)
+        yield
+    finally:
+        os.chdir(cd)
+
+
+async def freeze(
+    env_path: Path,
+    config: EnvironmentConfig,
+    lock_files_path: Path,
+) -> None:
+    lock_files_path.mkdir(exist_ok=True)
+
+    package_json_path = _write_package_json(config, lock_files_path)
+
+    with cd_to(lock_files_path):
+        process = await asyncio.create_subprocess_exec(
+            env_path / "bin" / "npm",
+            *(
+                "install",
+                "--package-lock-only",
+            ),
+            env=os.environ | {"PATH": f"{os.environ['PATH']}:{env_path / 'bin'}"},
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        await stream_both(process)
+        await process.wait()
+
+    if process.returncode != 0:
+        raise RuntimeError("Failed freezing dependencies {process.returncode=}")
+
+    package_lock_json_path = lock_files_path / "package-lock.json"
+    manifest = build_manifest(
+        source_dependencies=config.dependencies,
+        lock_files=(
+            package_json_path,
+            package_lock_json_path,
+        ),
+        lock_files_path=lock_files_path,
+    )
+    write_manifest(lock_files_path, manifest)
+
+
+async def sync(
+    env_path: Path,
+    config: EnvironmentConfig,
+    lock_files_path: Path,
+) -> None:
+    package_lock_path = lock_files_path / "package-lock.json"
+    package_json_path = lock_files_path / "package.json"
+
+    shutil.copy(package_lock_path, env_path / package_lock_path.name)
+    shutil.copy(package_json_path, env_path / package_json_path.name)
+
+    with cd_to(env_path):
+        process = await asyncio.create_subprocess_exec(
+            env_path / "bin" / "npm",
+            *(
+                "install",
+                "--no-save",
+            ),
+            env=os.environ | {"PATH": f"{os.environ['PATH']}:{env_path / 'bin'}"},
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        await stream_both(process)
+        await process.wait()
+
+    if process.returncode != 0:
+        raise RuntimeError("Failed syncing dependencies {process.returncode=}")
+
+
+async def run(
+    env_path: Path,
+    config: EnvironmentConfig,
+    unit: ExecutableUnit,
+) -> RunResult:
+    args: Sequence[str | Path] = (
+        "exec",
+        f"--prefix={env_path}",
+        unit.hook.command,
+        "--",
+        *unit.hook.args,
+        *unit.targets,
+    )
+    process = await asyncio.create_subprocess_exec(
+        env_path / "bin" / "npm",
+        *args,
+        env=os.environ | {"PATH": f"{os.environ['PATH']}:{env_path / 'bin'}"},
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    await stream_both(process)
+    await process.wait()
+
+    return RunResult.ok if process.returncode == 0 else RunResult.error
+
+
+backend: Final = Backend(
+    ecosystem="node",
+    bootstrap=bootstrap,
+    freeze=freeze,
+    sync=sync,
+    run=run,
+)

goose/backend/python.py

@@ -0,0 +1,185 @@
+import asyncio
+import asyncio.subprocess
+import os
+import sys
+from collections.abc import Iterable
+from contextlib import ExitStack
+from pathlib import Path
+from typing import Final
+
+from goose.config import EnvironmentConfig
+from goose.executable_unit import ExecutableUnit
+from goose.manifest import build_manifest
+from goose.manifest import write_manifest
+from goose.process import stream_both
+from goose.process import system_python
+
+from .base import Backend
+from .base import RunResult
+
+
+def _venv_python(env_path: Path) -> Path:
+    return env_path / "bin" / "python"
+
+
+def _bootstrap_env() -> dict[str, str]:
+    return os.environ | {
+        "PYTHONUNBUFFERED": "1",
+        "PIP_REQUIRE_VIRTUALENV": "true",
+        "PIP_DISABLE_PIP_VERSION_CHECK": "true",
+    }
+
+
+def _run_env(env_path: Path) -> dict[str, str]:
+    bin_path = env_path / "bin"
+    return os.environ | {
+        "PATH": f"{bin_path}:{os.environ['PATH']}",
+    }
+
+
+async def _create_virtualenv(env_path: Path) -> None:
+    process = await asyncio.create_subprocess_exec(
+        system_python(),
+        *("-m", "venv", str(env_path)),
+        env=_bootstrap_env(),
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    await stream_both(process)
+    await process.wait()
+    if process.returncode != 0:
+        raise RuntimeError("Failed creating virtualenv {process.returncode=}")
+
+
+async def _pip_install(
+    env_path: Path,
+    dependencies: Iterable[str],
+) -> None:
+    process = await asyncio.create_subprocess_exec(
+        _venv_python(env_path),
+        *("-m", "pip", "install", *dependencies),
+        env=_bootstrap_env(),
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    await stream_both(process)
+    await process.wait()
+    if process.returncode != 0:
+        raise RuntimeError("Failed installing packages {process.returncode=}")
+
+
+async def _pip_sync(
+    env_path: Path,
+    requirements_txt: Path,
+) -> None:
+    process = await asyncio.create_subprocess_exec(
+        env_path / "bin" / "pip-sync",
+        str(requirements_txt),
+        env=_bootstrap_env(),
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    await stream_both(process)
+    await process.wait()
+    if process.returncode != 0:
+        raise RuntimeError("Failed syncing dependencies {process.returncode=}")
+
+
+async def bootstrap(
+    env_path: Path,
+    config: EnvironmentConfig,
+) -> None:
+    print(f"Creating virtualenv {env_path.name}", file=sys.stderr)
+    await _create_virtualenv(env_path)
+
+    print("Installing pip-tools ...", file=sys.stderr)
+    await _pip_install(env_path, ("pip-tools",))
+
+
+async def freeze(
+    env_path: Path,
+    config: EnvironmentConfig,
+    lock_files_path: Path,
+) -> None:
+    lock_files_path.mkdir(exist_ok=True)
+
+    tmp_requirements_in = lock_files_path / "requirements.in"
+    requirements_txt = lock_files_path / "requirements.txt"
+
+    with ExitStack() as stack:
+        stack.callback(tmp_requirements_in.unlink, missing_ok=True)
+
+        # Write equivalent of a requirements.in.
+        with tmp_requirements_in.open("w") as fd:
+            for dependency in config.dependencies:
+                print(dependency, file=fd)
+
+        process = await asyncio.create_subprocess_exec(
+            env_path / "bin" / "pip-compile",
+            *(
+                "--upgrade",
+                "--strip-extras",
+                "--generate-hashes",
+                "--resolver=backtracking",
+                "--no-annotate",
+                "--no-header",
+                f"--output-file={requirements_txt}",
+                f"{tmp_requirements_in}",
+            ),
+            env=_bootstrap_env(),
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        await stream_both(process)
+        await process.wait()
+
+    if process.returncode != 0:
+        raise RuntimeError("Failed freezing dependencies {process.returncode=}")
+
+    manifest = build_manifest(
+        source_dependencies=config.dependencies,
+        lock_files=(requirements_txt,),
+        lock_files_path=lock_files_path,
+    )
+    write_manifest(lock_files_path, manifest)
+
+
+async def sync(
+    env_path: Path,
+    config: EnvironmentConfig,
+    lock_files_path: Path,
+) -> None:
+    requirements_txt = lock_files_path / "requirements.txt"
+
+    await _pip_sync(
+        env_path=env_path,
+        requirements_txt=requirements_txt,
+    )
+
+
+async def run(
+    env_path: Path,
+    config: EnvironmentConfig,
+    unit: ExecutableUnit,
+) -> RunResult:
+    process = await asyncio.create_subprocess_exec(
+        unit.hook.command,
+        *unit.hook.args,
+        *unit.targets,
+        env=_run_env(env_path),
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    await stream_both(process)
+    await process.wait()
+
+    return RunResult.ok if process.returncode == 0 else RunResult.error
+
+
+backend: Final = Backend(
+    ecosystem="python",
+    bootstrap=bootstrap,
+    freeze=freeze,
+    sync=sync,
+    run=run,
+)

goose/config.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from pathlib import Path
+from re import Pattern
+from typing import Literal
+from typing import NewType
+from typing import Self
+from typing import final
+
+import yaml
+from pydantic import model_validator
+
+from ._utils.pydantic import BaseModel
+
+
+@final
+class EcosystemConfig(BaseModel):
+    language: Literal["python", "node"]
+    version: str
+
+
+EnvironmentId = NewType("EnvironmentId", str)
+
+
+@final
+class EnvironmentConfig(BaseModel):
+    id: EnvironmentId
+    ecosystem: EcosystemConfig
+    dependencies: tuple[str, ...]
+
+
+@final
+class HookConfig(BaseModel):
+    id: str
+    environment: EnvironmentId
+    command: str
+    args: tuple[str, ...] = ()
+    parameterize: bool = True
+    types: frozenset[str] = frozenset()
+    exclude: tuple[Pattern, ...] = ()
+    read_only: bool = False
+
+
+@final
+class Config(BaseModel):
+    environments: tuple[EnvironmentConfig, ...]
+    hooks: tuple[HookConfig, ...]
+    exclude: tuple[Pattern, ...] = ()
+
+    @model_validator(mode="after")  # type: ignore[misc]
+    def validate_hook_environments_configured(self) -> Self:
+        environments = {env.id for env in self.environments}
+        for hook in self.hooks:
+            if hook.environment not in environments:
+                raise ValueError(f"Unknown hook environment: {hook.environment!r}")
+        return self
+
+    @model_validator(mode="after")  # type: ignore[misc]
+    def validate_hook_ids_unique(self) -> Self:
+        if len({hook.id for hook in self.hooks}) != len(self.hooks):
+            raise ValueError("Hook ids must be unique")
+        return self
+
+    @model_validator(mode="after")  # type: ignore[misc]
+    def validate_environment_ids_unique(self) -> Self:
+        if len({env.id for env in self.environments}) != len(self.environments):
+            raise ValueError("Environment ids must be unique")
+        return self
+
+
+def load_config(path: Path) -> Config:
+    with path.open("rb") as fd:
+        loaded = yaml.safe_load(fd)
+    return Config.model_validate(loaded)

goose/context.py

@@ -0,0 +1,34 @@
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+
+from .config import Config
+from .config import EnvironmentId
+from .config import load_config
+from .environment import Environment
+from .environment import build_environments
+from .paths import get_env_path
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Context:
+    config: Config
+    lock_files_path: Path
+    environments_path: Path
+    environments: Mapping[EnvironmentId, Environment]
+
+
+def gather_context(
+    config_path: Path,
+) -> Context:
+    lock_files_path = Path("./.goose").resolve()
+    lock_files_path.mkdir(exist_ok=True)
+    config = load_config(config_path)
+    environments_path = get_env_path()
+    return Context(
+        config=config,
+        # fixme: should be configurable.
+        lock_files_path=lock_files_path,
+        environments_path=environments_path,
+        environments=build_environments(config, environments_path, lock_files_path),
+    )