wynd 0.1.0__py3-none-any.whl

wynd/cli.py

@@ -0,0 +1,112 @@
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from . import wrangler
+from .host import warn_on_venv_mismatch
+from .project import WyndError, load_project
+from .shake import ShakePlan
+from .stage import stage
+from .sync import select_sdk, sync
+from .targets import select_target
+from .typegen import write_env
+
+__all__ = ["main"]
+
+# Reads the flags that choose the target and leaves everything else to Wrangler.
+# --env-file and --profile are Wrangler's other global value flags, read only so
+# their values aren't taken for the command.
+_parser = argparse.ArgumentParser(add_help=False, allow_abbrev=False)
+_parser.add_argument("-c", "--config")
+_parser.add_argument("-e", "--env")
+_parser.add_argument("--cwd")
+_parser.add_argument("--env-file", action="append")
+_parser.add_argument("--profile")
+# Wrangler flags that change the target after Wynd has installed for the
+# config's. Wynd refuses them.
+_parser.add_argument("--compatibility-date")
+_parser.add_argument("--compatibility-flags", "--compatibility-flag", action="append")
+_parser.add_argument("--latest", action="store_true")
+
+# Wrangler 4.129.0's subcommands. Of these, only `versions upload` uploads code,
+# and `preview` uploads code when it has none of them.
+SUBCOMMANDS = {
+    "versions": {"view", "list", "upload", "deploy", "secret"},
+    "preview": {"delete", "settings", "secret", "base-config"},
+}
+
+# Takes only the config flag, so the remaining arguments keep their order.
+_config_parser = argparse.ArgumentParser(add_help=False, allow_abbrev=False)
+_config_parser.add_argument("-c", "--config")
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Run a `wynd` command line. Commands Wynd doesn't own go to Wrangler."""
+    args = sys.argv[1:] if argv is None else argv
+    options, rest = _parser.parse_known_args(args)
+    flow = _flow(rest)
+    if flow == "passthrough":
+        return wrangler.run(args)
+
+    if flow in ("dev", "upload") and (
+        options.compatibility_date or options.compatibility_flags or options.latest
+    ):
+        print(
+            "wynd: error: --compatibility-date, --compatibility-flags and --latest "
+            "change the Python version after Wynd installs packages. Set "
+            "compatibility_date and compatibility_flags in the Wrangler config.",
+            file=sys.stderr,
+        )
+        return 1
+
+    try:
+        cwd = Path.cwd() / options.cwd if options.cwd else Path.cwd()
+        env = options.env or os.environ.get("CLOUDFLARE_ENV")
+        project = load_project(cwd, options.config, env)
+        if flow == "types":
+            write_env(project, check="--check" in rest)
+            return 0
+        target = select_target(project)
+        sync(project, target)
+        if flow != "sync" and select_sdk(project.dependencies) == "crosswind-workers":
+            write_env(project)
+        staged = stage(project) if flow == "upload" else None
+    except WyndError as error:
+        print(f"wynd: error: {error}", file=sys.stderr)
+        return 1
+
+    if flow == "sync":
+        return 0
+    if staged is not None:
+        return _upload(args, rest, *staged)
+
+    warn_on_venv_mismatch(project, target)
+    return wrangler.run(args)
+
+
+def _flow(rest: list[str]) -> str:
+    """Sort a command line into the upload, dev, sync, types or passthrough flow."""
+    words = [arg for arg in rest if not arg.startswith("-")]
+    command = words[0] if words else ""
+    # A known name, not the second word, because a flag's value can come first.
+    known = SUBCOMMANDS.get(command, set())
+    subcommand = next((word for word in words[1:] if word in known), "")
+
+    if (
+        command == "deploy"
+        or (command == "versions" and subcommand == "upload")
+        or (command == "preview" and not subcommand)
+    ):
+        return "upload"
+    return command if command in ("dev", "sync", "types") else "passthrough"
+
+
+def _upload(args: list[str], rest: list[str], path: Path, plan: ShakePlan) -> int:
+    """Run Wrangler on the staged config in place of the project's."""
+    if "--dry-run" in rest:
+        # Flushed, so it comes before Wrangler's output in a pipe.
+        print(f"wynd: {plan.size_report()}", flush=True)
+
+    _, rest = _config_parser.parse_known_args(args)
+    return wrangler.run([*rest, "--config", str(path)])

wynd/host.py

@@ -0,0 +1,28 @@
+import re
+import sys
+
+from .project import Project
+from .targets import Target
+
+__all__ = ["warn_on_venv_mismatch"]
+
+
+def warn_on_venv_mismatch(project: Project, target: Target) -> None:
+    """Warn when the editor's .venv runs another Python minor than the target."""
+    try:
+        pyvenv = (project.root / ".venv" / "pyvenv.cfg").read_text()
+    except FileNotFoundError:
+        return
+
+    match = re.search(r"^version_info\s*=\s*(\d+\.\d+)", pyvenv, re.MULTILINE)
+    if match is None or match.group(1) == target.version:
+        return
+
+    flags = ", ".join(f for f in project.compatibility_flags if "python_workers" in f)
+    print(
+        f"warning: .venv is Python {match.group(1)} but {project.config_path.name}"
+        f" targets {target.version} ({flags}, {project.compatibility_date}).\n"
+        "Editor types may differ from production."
+        f" To match: uv venv --python {target.version} && uv sync",
+        file=sys.stderr,
+    )

wynd/project.py

@@ -0,0 +1,141 @@
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import jsonc
+
+__all__ = ["Project", "WyndError", "load_project"]
+
+# Wrangler walks every parent for one name before it tries the next.
+CONFIG_NAMES = ("wrangler.json", "wrangler.jsonc", "wrangler.toml")
+
+# Top-level keys Wynd reads that an environment inherits when it leaves them out.
+# Bindings, vars and the rest stay with the table that sets them.
+INHERITED = (
+    "main",
+    "base_dir",
+    "compatibility_date",
+    "compatibility_flags",
+    "rules",
+    "assets",
+    "build",
+    "python_modules",
+    # Wrangler 4.129 inherits logfwdr, although it holds bindings.
+    "logfwdr",
+)
+
+
+class WyndError(Exception):
+    """An error Wynd reports to the user as one message."""
+
+
+@dataclass(frozen=True)
+class Project:
+    root: Path
+    config_path: Path
+    # The config file as parsed, every environment included.
+    config: dict[str, Any]
+    # The chosen environment's table over the top-level keys it inherits, or
+    # the top level without an environment.
+    settings: dict[str, Any]
+    main: str | None
+    base_dir: str | None
+    compatibility_date: str | None
+    compatibility_flags: tuple[str, ...]
+    dependencies: tuple[str, ...]
+    allow_build: bool
+    # Modules the shaker keeps although nothing imports them by a literal name.
+    keep: tuple[str, ...]
+
+    @property
+    def python_modules(self) -> Path:
+        # Wrangler collects python_modules/ beside the config file.
+        return self.config_path.parent / "python_modules"
+
+    @property
+    def source_dir(self) -> Path:
+        """The module root: base_dir, or the entrypoint's directory."""
+        if self.main is None:
+            raise WyndError(f"{self.config_path.name} sets no main")
+        config_dir = self.config_path.parent.resolve()
+        return (config_dir / (self.base_dir or Path(self.main).parent)).resolve()
+
+    @property
+    def wynd_dir(self) -> Path:
+        # Wynd's builds and state.
+        return self.root / ".wynd"
+
+
+def load_project(cwd: Path, config: str | None, env: str | None) -> Project:
+    """Read the project the way Wrangler would for `-c config` and `-e env`."""
+    root = _find_up(cwd, "pyproject.toml")
+    if root is None:
+        raise WyndError(f"no pyproject.toml in {cwd} or any parent directory")
+
+    config_path = cwd / config if config else _find_config(cwd)
+    raw = _read(config_path)
+    settings = _environment(raw, env, config_path.name)
+
+    pyproject = _read(root / "pyproject.toml")
+    wynd = pyproject.get("tool", {}).get("wynd", {})
+    keep = wynd.get("keep", [])
+    if not isinstance(keep, list) or not all(isinstance(k, str) for k in keep):
+        raise WyndError("[tool.wynd] keep must be a list of module names")
+
+    date = settings.get("compatibility_date")
+    return Project(
+        root=root,
+        config_path=config_path,
+        config=raw,
+        settings=settings,
+        main=settings.get("main"),
+        base_dir=settings.get("base_dir"),
+        # TOML parses a bare date as datetime.date. Wrangler reads it as text.
+        compatibility_date=None if date is None else str(date),
+        compatibility_flags=tuple(settings.get("compatibility_flags", ())),
+        dependencies=tuple(pyproject.get("project", {}).get("dependencies", ())),
+        allow_build=bool(wynd.get("allow-build")),
+        keep=tuple(keep),
+    )
+
+
+def _environment(config: dict[str, Any], env: str | None, name: str) -> dict[str, Any]:
+    """The chosen environment's table over the top-level keys it inherits."""
+    envs = config.get("env") or {}
+    # Without any env table, Wrangler warns and uses the top level, as Wynd does.
+    if env is None or not envs:
+        return config
+    if env not in envs:
+        raise WyndError(f"{name} has no environment named {env!r}")
+
+    # An environment's value replaces the top-level one; nothing merges.
+    inherited = {key: config[key] for key in INHERITED if key in config}
+    return {**inherited, **envs[env]}
+
+
+def _find_up(start: Path, name: str) -> Path | None:
+    for directory in (start, *start.parents):
+        if (directory / name).is_file():
+            return directory
+    return None
+
+
+def _find_config(cwd: Path) -> Path:
+    for name in CONFIG_NAMES:
+        directory = _find_up(cwd, name)
+        if directory is not None:
+            return directory / name
+    raise WyndError(f"no Wrangler config ({', '.join(CONFIG_NAMES)}) found from {cwd}")
+
+
+def _read(path: Path) -> dict[str, Any]:
+    try:
+        text = path.read_text()
+        if path.suffix == ".toml":
+            return tomllib.loads(text)
+        return jsonc.loads(text)
+    except OSError as error:
+        raise WyndError(f"cannot read {path}: {error.strerror}") from None
+    except (tomllib.TOMLDecodeError, ValueError) as error:
+        raise WyndError(f"cannot parse {path}: {error}") from None