boatyard 0.6.0.dev170__py3-none-any.whl

boatyard/verbs/score.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import Annotated, NamedTuple
+
+import typer
+from bashrun.bash import bash, bash_check, bash_output
+
+from boatyard import dockerfiles
+from boatyard.config.config import ConfigFile, Target
+from boatyard.config.lock import LOCK_PATH, LockFile
+from boatyard.yaml import load_yaml_model
+from boatyard.score import (
+    SECRETS_FILE,
+    SECRETS_OUTPUT,
+    SecretsDeclaration,
+    write_file,
+)
+from boatyard.score_compose import generate_compose
+from boatyard.paths import DEFAULT_CONFIG_PATH
+from boatyard.score_k8s import generate_k8s
+
+app = typer.Typer()
+
+
+class ToolRequirement(NamedTuple):
+    binary: str
+    version: str
+    probe: str
+    archive: str
+    extract: str
+
+
+@app.command()
+def generate_score(
+    target: Annotated[Target, typer.Option(help="Which Score artifact to generate.")] = "both",
+    local: Annotated[
+        bool,
+        typer.Option(
+            "--local",
+            help="Generate for a local cluster: local storage class, written to the configured local output path.",
+        ),
+    ] = False,
+    check: Annotated[
+        bool,
+        typer.Option("--check", help="Regenerate and exit 1 when the committed artifacts are stale."),
+    ] = False,
+) -> None:
+    if check and local:
+        raise typer.BadParameter("--check and --local are mutually exclusive")
+    root = Path.cwd()
+    config_path = root / DEFAULT_CONFIG_PATH
+    config = ConfigFile.load(config_path) if config_path.is_file() else None
+    if config is None or not (config.local_service_entries() or config.k8s):
+        if check:
+            print("no local service entries and no k8s section; nothing to check")
+            return
+        raise ValueError("boatyard.yml declares no local service entries and no k8s section")
+    local_entries = config.local_service_entries()
+
+    if config.k8s is None and target in ("k8s", "both"):
+        message = (
+            "--target k8s: this config declares no k8s section (compose-only)"
+            if target == "k8s"
+            else "--target both: this config declares no k8s section; pass --target compose"
+        )
+        raise typer.BadParameter(message)
+    if not local_entries and target in ("compose", "both"):
+        message = (
+            "--target compose: this config declares no local service entries (k8s-only)"
+            if target == "compose"
+            else "--target both: this config declares no local service entries; pass --target k8s"
+        )
+        raise typer.BadParameter(message)
+    if config.k8s is None and local:
+        raise typer.BadParameter("--local requires a k8s section; this config declares none")
+
+    # Require the build keys, derive the tree tags, and load the lock.
+    if not (config.repository or config.base_images):
+        raise ValueError("repository or base_images is required in boatyard.yml")
+    service_shas = dockerfiles.compute_service_shas(root, config.service_builds)
+    lock_path = root / LOCK_PATH
+    if not lock_path.is_file():
+        raise ValueError(f"{lock_path.as_posix()}: the image lock is required")
+    lock = LockFile.load(lock_path, config)
+    if not lock.images and not lock.charts:
+        raise ValueError(f"{lock_path.as_posix()}: the image lock carries no entries")
+
+    # Require the secrets declaration; an empty file parses as the empty declaration.
+    secrets_path = root / SECRETS_FILE
+    if not secrets_path.is_file():
+        raise ValueError(f"{secrets_path.as_posix()}: the secrets declaration is required")
+    secrets = load_yaml_model(SecretsDeclaration, secrets_path)
+
+    ensure_tools(
+        [
+            ToolRequirement(
+                binary=binary,
+                version=version,
+                probe=f"{binary} {version}",
+                archive=(
+                    f"https://github.com/score-spec/{binary}/releases/download/{version}/"
+                    f"{binary}_{version}_linux_amd64.tar.gz"
+                ),
+                extract=binary,
+            )
+            for binary, version in (
+                ("score-compose", config.score_compose_version),
+                ("score-k8s", config.score_k8s_version),
+            )
+        ]
+        + [
+            ToolRequirement(
+                binary="helm",
+                version=config.helm_version,
+                probe=f'"v{config.helm_version}"',
+                archive=f"https://get.helm.sh/helm-v{config.helm_version}-linux-amd64.tar.gz",
+                extract="--strip-components=1 linux-amd64/helm",
+            )
+        ]
+    )
+
+    outputs: list[Path] = []
+    if target in ("both", "compose"):
+        outputs.extend(generate_compose(config, lock, service_shas, secrets))
+
+    if target in ("both", "k8s") and config.k8s is not None:
+        outputs.append(generate_k8s(config, config.k8s, lock, service_shas, local, secrets))
+
+    secrets_output = root / SECRETS_OUTPUT
+    secrets_output.parent.mkdir(parents=True, exist_ok=True)
+    write_file(
+        secrets_output,
+        "# Generated by generate-score from the secrets declaration\n"
+        + "".join(f"{name}\n" for name, key in sorted(secrets.root.items()) if key.mint),
+    )
+    outputs.append(secrets_output)
+
+    if check:
+        pathspec = " ".join(output.as_posix() for output in outputs)
+        if bash_output(f"git status --porcelain -- {pathspec}").strip():
+            bash(f"git diff -- {pathspec}")
+            raise SystemExit(
+                "score artifacts are stale. Run 'generate-score' and commit the result as 'Run generate-score'."
+            )
+
+
+def ensure_tools(requirements: list[ToolRequirement]) -> None:
+    for requirement in requirements:
+        if bash_check(f"{requirement.binary} version") and requirement.probe in bash_output(
+            f"{requirement.binary} version"
+        ):
+            continue
+        print(f"Install {requirement.binary} {requirement.version}")
+        sudo = "sudo " if os.geteuid() != 0 else ""
+        with TemporaryDirectory() as directory:
+            archive = Path(directory) / Path(requirement.archive).name
+            bash(f"curl -fsSL {requirement.archive} -o {archive.as_posix()}")
+            bash(f"{sudo}tar -xzf {archive.as_posix()} -C /usr/local/bin {requirement.extract}")

boatyard/verbs/tree_tags.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from boatyard import dockerfiles
+from boatyard.config.config import ConfigFile
+from boatyard.dockerfiles import service_sha_env
+from boatyard.paths import DEFAULT_CONFIG_PATH
+
+app = typer.Typer()
+
+
+@app.command()
+def tree_tags(
+    services: Annotated[
+        list[str] | None,
+        typer.Argument(help="Derived service names; each answers its HEAD tree tag, one per line."),
+    ] = None,
+) -> None:
+    root = Path.cwd()
+    config = ConfigFile.load(root / DEFAULT_CONFIG_PATH)
+    vocabulary = sorted(config.service_builds)
+    if not services:
+        raise typer.BadParameter(
+            f"at least one service name is required; this repo derives {vocabulary or 'no services'}"
+        )
+    unknown = [name for name in services if name not in config.service_builds]
+    if unknown:
+        raise typer.BadParameter(f"unknown service(s) {unknown}; this repo derives {vocabulary}")
+    shas = dockerfiles.compute_service_shas(config.root, config.service_builds)
+    for name in services:
+        print(shas[service_sha_env(name)])

boatyard/verbs/up.py

@@ -0,0 +1,265 @@
+from __future__ import annotations
+
+import os
+from collections.abc import Generator, Mapping
+from contextlib import ExitStack, contextmanager
+from itertools import groupby
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+from typing import Annotated
+
+import typer
+import yaml
+from bashrun.bash import bash_handoff
+
+from boatyard.build import run_build
+from boatyard.compose import compose_command
+from boatyard.config.config import (
+    CADDY_IMAGE,
+    ConfigFile,
+    EDGE_SERVICE_NAME,
+    OCI_REFERENCE_PREFIX,
+    Yaml,
+    bundle_lock_key,
+    compose_bundle_output_path,
+    double_dollars,
+    env_lock_slot,
+    scan_bundle_texts,
+)
+from boatyard.config.lock import LockFile
+from boatyard.config.values import ValuesFile
+from boatyard.paths import DEFAULT_CONFIG_PATH, LOCK_PATH, VALUES_FILE
+
+# Name the edge listener port and its configs key
+EDGE_LISTEN_PORT = 8443
+EDGE_CONFIG_NAME = "devkit-edge-caddyfile"
+
+app = typer.Typer()
+
+
+@app.command()
+def up(
+    attached: Annotated[bool, typer.Option("--attached", "-a", help="Run in foreground (not detached)")] = False,
+    quiet_pull: Annotated[
+        bool,
+        typer.Option("--quiet-pull", "-q", help="Suppress per-layer pull progress (still shows pull/push totals)."),
+    ] = False,
+    build: Annotated[
+        bool,
+        typer.Option("--build", help="Build all images locally before bringing the stack up"),
+    ] = False,
+) -> None:
+    # Load the config and the typed machine values from the working directory
+    root = Path.cwd()
+    config = ConfigFile.load(root / DEFAULT_CONFIG_PATH)
+    if not (root / VALUES_FILE).exists():
+        raise ValueError(f"{VALUES_FILE.as_posix()} is required")
+    config_values = ValuesFile.load(root / VALUES_FILE, config)
+
+    # Require the config to declare a compose stack
+    if not config.services:
+        raise ValueError("boatyard.yml must declare services")
+
+    # Resolve the chosen options into leaf services
+    services = config.resolve_services(config_values.choices)
+
+    # Project the consumer lock's manifest references and seed the assembly accumulators
+    lock = LockFile.load(config.root / LOCK_PATH, config)
+    consumer_entries = lock.manifest_references(config_values.platform)
+    entries: dict[str, str] = {}
+    includes: list[Yaml] = []
+    requirements: dict[str, list[str]] = {}
+
+    # Collect each entry's include, requirements, and env entries in declaration order
+    for service in services:
+        name = service.name
+
+        # Include a remote ref as its lock-pinned digest
+        if service.entry.ref is not None and name not in config_values.path_overrides:
+            key = bundle_lock_key(name)
+            pinned = lock.require(key, f"bundle {name!r}")
+            requirements[name] = lock.bundles[key].requires
+            includes.append(f"{OCI_REFERENCE_PREFIX}{pinned}")
+            continue
+
+        # Include a local entry through its generated output
+        if service.entry.ref is None:
+            bundle_compose_path = compose_bundle_output_path(config.root, name)
+            if not bundle_compose_path.is_file():
+                raise ValueError(
+                    f"selected entry {name!r} has no bundle output {bundle_compose_path.as_posix()}; generate-score writes it"
+                )
+            lock_references = consumer_entries
+        else:
+            # Include an overridden ref through its local path
+            candidate = config_values.path_overrides[name]
+            bundle_compose_path = (candidate if candidate.is_absolute() else config.root / candidate).resolve()
+            if not bundle_compose_path.is_file():
+                raise ValueError(f"path_overrides.{name}: {bundle_compose_path.as_posix()} does not exist")
+
+            # Walk up from the override to the boatyard.yml-bearing producer root
+            producer_root = next(
+                (ancestor for ancestor in bundle_compose_path.parents if (ancestor / DEFAULT_CONFIG_PATH).is_file()),
+                None,
+            )
+            if producer_root is None:
+                raise ValueError(
+                    f"{bundle_compose_path.as_posix()}: no boatyard.yml-bearing repo root above the bundle override"
+                )
+
+            # Project the producer lock's manifest references under the consumer's platform
+            lock_references = LockFile.load(
+                producer_root / LOCK_PATH, ConfigFile.load(producer_root / DEFAULT_CONFIG_PATH)
+            ).manifest_references(config_values.platform)
+
+        # Scan the bundle file for its requirements and refuse the reserved edge service
+        text = bundle_compose_path.read_text(encoding="utf-8")
+        scan = scan_bundle_texts(name, service.routes, service.ports, [text])
+        if EDGE_SERVICE_NAME in scan.service_names:
+            raise ValueError(
+                f"{bundle_compose_path.as_posix()}: "
+                f"the included bundle defines the reserved service {EDGE_SERVICE_NAME!r}"
+            )
+
+        # Record the entry's requirements, include the file by absolute path, and fan its lock keys under the marker
+        requirements[name] = scan.requires
+        includes.append(bundle_compose_path.resolve().as_posix())
+        entries.update({env_lock_slot(name, key): value for key, value in lock_references.items()})
+
+    # Refuse bundles whose requirements no environment source fills, naming shell-set slots as ignored
+    filled = {variable for variable, value in {**config_values.variables, **entries}.items() if value}
+    missing = {
+        name: sorted(set(required) - filled) for name, required in requirements.items() if set(required) - filled
+    }
+    if missing:
+        name, absent = min(missing.items())
+        ignored = sorted(shell_name for shell_name in absent if os.environ.get(shell_name))
+        note = f"; {', '.join(ignored)} set in the shell and ignored" if ignored else ""
+        raise ValueError(
+            f"bundle {name!r} requires {absent}, which no environment source sets "
+            f"(boatyard.values.yaml or the lock env file){note}"
+        )
+
+    # Group the ports under their namespaced owners into per-service stanzas
+    document_services: dict[str, Yaml] = {
+        f"{service.name}-{owner}": {
+            "ports": [port.model_dump(exclude={"service"}, exclude_none=True) for port in owner_ports]
+        }
+        for service in services
+        for owner, owner_ports in groupby(
+            sorted(service.ports, key=lambda port: port.service), key=lambda port: port.service
+        )
+    }
+
+    # Assemble the root document, sections omitted when empty
+    document: dict[str, Yaml] = {"name": config.project_name}
+
+    # Render the edge and its Caddyfile when a gateway is declared
+    if config.gateway is not None:
+        edge: dict[str, Yaml] = {
+            "image": consumer_entries[CADDY_IMAGE],
+            "configs": [{"source": EDGE_CONFIG_NAME, "target": "/etc/caddy/Caddyfile"}],
+            "ports": [{"target": str(EDGE_LISTEN_PORT), "published": config.gateway, "protocol": "tcp"}],
+            # Attach the edge to every selected bundle's network
+            "networks": dict.fromkeys(f"{service.name}-net" for service in services),
+        }
+        if any(service.auth for service in services):
+            if config_values.public_url is None:
+                raise ValueError("an auth option is selected; public_url is required in boatyard.values.yaml")
+            edge["environment"] = config_values.public_url.forwarded
+        document_services[EDGE_SERVICE_NAME] = edge
+
+        # Render one handle block per route in declaration order
+        lines = [f":{EDGE_LISTEN_PORT} {{"]
+        for service, index, route in (
+            (service, index, route) for service in services for index, route in enumerate(service.routes)
+        ):
+            upstream = f"{service.name}-{route.upstream}"
+            opener = (
+                ("\thandle_path" if route.strip_prefix else "\thandle")
+                + ("" if route.path == "/*" else f" {route.path}")
+                + " {"
+            )
+            if route.raw is not None:
+                lines.extend((opener, *["\t\t" + line for line in route.raw.splitlines()], "\t}"))
+                continue
+
+            if service.auth and index == 0:
+                lines.extend((
+                    opener,
+                    *[
+                        f"\t\treverse_proxy {upstream} {{",
+                        "\t\t\theader_up X-Forwarded-Proto {$FORWARDED_PROTO}",
+                        "\t\t\theader_up X-Forwarded-Port {$FORWARDED_PORT}",
+                        "\t\t}",
+                    ],
+                    "\t}",
+                ))
+                continue
+
+            lines.extend((opener, *[f"\t\treverse_proxy {upstream}"], "\t}"))
+        lines.append("}")
+        document["configs"] = {EDGE_CONFIG_NAME: {"content": double_dollars("\n".join(lines) + "\n")}}
+
+    if includes:
+        document["include"] = includes
+    if document_services:
+        document["services"] = document_services
+
+    with ExitStack() as stack:
+        # Materialize the env file
+        with NamedTemporaryFile("w", suffix=".env", prefix="devkit-env-", delete=False, encoding="utf-8") as handle:
+            handle.write(
+                "".join(
+                    f"# {header}\n{render_env_entries(section)}"
+                    for header, section in ((VALUES_FILE.name, config_values.variables), (LOCK_PATH.name, entries))
+                    if section
+                )
+            )
+        materialized_env_file = Path(handle.name)
+        stack.enter_context(lock_env_unwind(materialized_env_file))
+
+        # Materialize the compose file
+        with NamedTemporaryFile(
+            "w", suffix=".yaml", prefix="devkit-assembly-", delete=False, encoding="utf-8"
+        ) as handle:
+            handle.write(yaml.safe_dump(document, sort_keys=False, default_flow_style=False))
+        materialized_compose_file = Path(handle.name)
+        stack.callback(materialized_compose_file.unlink, missing_ok=True)
+
+        # Build local images
+        if build:
+            run_build(config=config)
+
+        # Hand off to docker compose
+        bash_handoff(
+            compose_command(
+                root,
+                materialized_compose_file,
+                "up",
+                *["--pull", "missing", *(["--quiet-pull"] if quiet_pull else []), *(["-d"] if not attached else [])],
+                env_file=materialized_env_file,
+                slot_names=[
+                    *config_values.variables,
+                    *entries,
+                    *(name for required in requirements.values() for name in required),
+                ],
+            )
+        )
+
+
+def render_env_entries(entries: Mapping[str, str]) -> str:
+    # Render the entries as sorted dotenv lines
+    return "".join(f"{name}={reference}\n" for name, reference in sorted(entries.items()))
+
+
+@contextmanager
+def lock_env_unwind(path: Path) -> Generator[None]:
+    # Keep the env file on failure echoing only its path, since contents may carry secrets, and unlink it on success
+    try:
+        yield
+    except BaseException:
+        print(f"env file kept for inspection: {path}")
+        raise
+
+    path.unlink(missing_ok=True)

boatyard/yaml.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+from pydantic import BaseModel
+
+
+def load_yaml_model[ModelT: BaseModel](
+    model: type[ModelT], path: Path, context: dict[str, object] | None = None
+) -> ModelT:
+    source = path.as_posix()
+    text = path.read_text(encoding="utf-8")
+    document_node = yaml.SafeLoader(text).get_single_node()
+    if document_node is not None:
+        _reject_duplicate_keys(document_node, source)
+    loaded: object = yaml.safe_load(text)
+    if loaded is None:
+        loaded = {}
+    return model.model_validate(loaded, context=context)
+
+
+def _reject_duplicate_keys(node: yaml.Node, source: str) -> None:
+    if isinstance(node, yaml.MappingNode):
+        seen: set[object] = set()
+        for key_node, value_node in node.value:
+            key = key_node.value if isinstance(key_node, yaml.ScalarNode) else repr(key_node.value)
+            if key in seen:
+                raise ValueError(f"{source}: line {key_node.start_mark.line + 1}: duplicate key {key!r}")
+            seen.add(key)
+            _reject_duplicate_keys(value_node, source)
+    elif isinstance(node, yaml.SequenceNode):
+        for item in node.value:
+            _reject_duplicate_keys(item, source)

boatyard-0.6.0.dev170.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.5
+Name: boatyard
+Version: 0.6.0.dev170
+Summary: Deploy-files definition language and compiler, plus a runtime for the compose target
+License-File: LICENSE
+License-File: NOTICE
+Requires-Python: >=3.13
+Requires-Dist: bashrun>=0.1.0
+Requires-Dist: packaging>=24.1
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: typer>=0.17.4

boatyard-0.6.0.dev170.dist-info/RECORD

@@ -0,0 +1,42 @@
+boatyard/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+boatyard/build.py,sha256=Ys8UmebsLzfOnUpfpuvCSeIBX1A1DOcnNxkf6QyntE8,10666
+boatyard/cli.py,sha256=i6cyJpHXIb3_9O1i2yobhS1LaE1byeSPs91ZWbC-ZGE,720
+boatyard/compose.py,sha256=XL29GyVqMVsfNcgirVzwqUCyVwoiPx59aGBu6fUSgx4,939
+boatyard/crane.py,sha256=hcIMCE5CLQKFgpyySVJubuuJuFJ6MST30ws3LWuSEfo,627
+boatyard/dockerfiles.py,sha256=PIRmxSCkgWBRYz7wHTE2XnzsXLa9mgSd-c2jTiQU63w,8706
+boatyard/lock.py,sha256=rCbiGlZv8gsD3nRqqapfzQB7Lemff-pjaXnRGiyBMDY,9464
+boatyard/markers.py,sha256=fTTEx33phwxZxZecLhkQkWTcJgLJ0h6ZZQl6DSqjtvk,7393
+boatyard/paths.py,sha256=gpR3ZhyciIFQQQGlvCPCxS8SFfVbSWrSw7gMiKiXUqs,150
+boatyard/publish.py,sha256=XwQubwpTPDcAMgCxLjg5RCrIsWIWxmrEmzyBZZOuOpQ,2667
+boatyard/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+boatyard/score.py,sha256=NC1Oi4NMGU-85iHt7h8PYdze4DZTZyMex6MG7sANdus,9641
+boatyard/score_compose.py,sha256=K4QD6VlEIXqGqmRZq8VpME0aYRR2RxQszVsQBSlJvkM,10011
+boatyard/score_k8s.py,sha256=ZsSC5qukYY0FcLfjqhiVGCr1bFbUqQYGaPuIYCQeqCo,5040
+boatyard/temp.py,sha256=fV1RYL7oamnoAsmDEx0yx4i4hIjLykT7hCuiiNL_7XA,131
+boatyard/yaml.py,sha256=xoGfpaHPHxjSaMEkoy3BYxX2sRhhmVvM6SPh2zIP5cg,1236
+boatyard/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+boatyard/config/config.py,sha256=pexCK7WNXL6JXn5Tc_WEZ-y6AqaB7FLVwkRon_7mATg,30937
+boatyard/config/lock.py,sha256=qyjMvb6QgM5PSlYVg44oDNt195p52oY7GsPGllbOksk,6805
+boatyard/config/values.py,sha256=FWHeXFENgJaO565qzffZw4k9USAgRc8ditYPeveBNNg,7668
+boatyard/score_patch_templates/gpu-cuda.tpl,sha256=kJFpV0mzeW48cAr3hw97n6EmpW9w7SETAyTdhPO5YDQ,1032
+boatyard/score_patch_templates/gpu-pod.tpl,sha256=c3plZTU6MrYKZXViFc0orXrFXS4QyQ7BuKesMkgWHic,1942
+boatyard/score_patch_templates/gpu-rocm.tpl,sha256=7RdEapTwFPzZ-cuOLrXeTR50sHOZyI-_BAph5Mtag94,1148
+boatyard/score_patch_templates/probe-adapter-healthchecks.tpl,sha256=B3dDUS1wWezwunxPpyfHlPwW2hkCBM-xyIOfqEVeXzM,2172
+boatyard/score_patch_templates/restart.tpl,sha256=d_tAuZgw6Imwf8gpRWMqM4gjsZZ786VMAUZ9mQ-lvW8,909
+boatyard/score_patch_templates/scale-to-zero.tpl,sha256=CFm08MWJJUw0BeSx_HkQKon3qJcz8DN0LZCMTIyA-X8,1120
+boatyard/verbs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+boatyard/verbs/build.py,sha256=uFUXzV8wzOWUdH7YFHzdwpcjlqNDRyAyRMpcxW81jq0,2015
+boatyard/verbs/down.py,sha256=qp-BthIEskhB1nvE_zFY5tF_He1-BOx1ts0BSY9FrpA,1267
+boatyard/verbs/lock.py,sha256=zDb_vKaZr0WjYVMZbjwvKHUyuG3kUJ0TjyMyYL-Rdi8,1089
+boatyard/verbs/matrix.py,sha256=Mli1TUAGkF5Y7vCD-Nla6Sq6kF91c-FcW-3O5RGCVx0,1956
+boatyard/verbs/mirror.py,sha256=xCXM3ic9AuNRSkOwLTVCbvgfGT59KwPEXK4BQMeRcSY,1741
+boatyard/verbs/publish.py,sha256=9m4jsD8KT_uliyLlotLOz3YWyYNq5OmUH-kgnlQaqro,5496
+boatyard/verbs/score.py,sha256=APqmm9A7sut3ZqJ9AtjWGtLD33eItbiH5PM2Fose7fw,6294
+boatyard/verbs/tree_tags.py,sha256=BN57sA42Z5g7aeAxVEsmGXegRt0idj9RUi96v1Dv7SA,1145
+boatyard/verbs/up.py,sha256=17wUfxkL4ewZXxAIojnZavo4h4UraEh7Kbdv18WfBZE,11239
+boatyard-0.6.0.dev170.dist-info/METADATA,sha256=RryIMz3tdmNnQJ2s9BuoqZBz4khkBUP1wmgs1G0aXkw,369
+boatyard-0.6.0.dev170.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+boatyard-0.6.0.dev170.dist-info/entry_points.txt,sha256=vuiOwN-ufRd_fxnl3DIG_2V3kcv05l0kRXlVhFIPgNs,46
+boatyard-0.6.0.dev170.dist-info/licenses/LICENSE,sha256=RFhQPdSOiMTguUX7JSoIuTxA7HVzCbj_p8WU36HjUQQ,10947
+boatyard-0.6.0.dev170.dist-info/licenses/NOTICE,sha256=jvglZza3GCdN7v4_TLuXUqX9C_uABlwAKUkcIeKwk_8,26
+boatyard-0.6.0.dev170.dist-info/RECORD,,

boatyard-0.6.0.dev170.dist-info/WHEEL

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

boatyard-0.6.0.dev170.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+boatyard = boatyard.cli:app