workers-py 1.6.1__py3-none-any.whl → 1.7.0__py3-none-any.whl

pywrangler/cli.py

@@ -2,13 +2,17 @@ import logging
 import subprocess
 import sys
 import textwrap
+from typing import Never
+
 import click
 
+from .sync import sync
 from .utils import (
-    setup_logging,
-    write_success,
     WRANGLER_COMMAND,
     WRANGLER_CREATE_COMMAND,
+    check_wrangler_version,
+    setup_logging,
+    write_success,
 )
 
 setup_logging()
@@ -16,7 +20,7 @@ logger = logging.getLogger("pywrangler")
 
 
 class ProxyToWranglerGroup(click.Group):
-    def get_help(self, ctx):
+    def get_help(self, ctx: click.Context) -> str:
         """Override to add custom help content."""
         # Get the default help text
         help_text = super().get_help(ctx)
@@ -28,6 +32,7 @@ class ProxyToWranglerGroup(click.Group):
                 capture_output=True,
                 text=True,
                 timeout=10,
+                check=False,
             )
             if result.returncode == 0:
                 wrangler_help = result.stdout
@@ -47,7 +52,7 @@ class ProxyToWranglerGroup(click.Group):
 
         return help_text
 
-    def get_command(self, ctx, cmd_name):
+    def get_command(self, ctx: click.Context, cmd_name: str) -> click.Command:
         command = super().get_command(ctx, cmd_name)
 
         if command is None:
@@ -58,11 +63,9 @@ class ProxyToWranglerGroup(click.Group):
                 remaining_args = []
 
             if cmd_name in ["dev", "publish", "deploy", "versions"]:
-                ctx.invoke(sync_command, force=False, directly_requested=False)
+                sync(force=False)
 
             if cmd_name == "dev":
-                from .sync import check_wrangler_version
-
                 check_wrangler_version()
 
             if cmd_name == "init":
@@ -78,7 +81,7 @@ class ProxyToWranglerGroup(click.Group):
         return command
 
 
-def get_version():
+def get_version() -> str:
     """Get the version of pywrangler."""
     try:
         from importlib.metadata import version
@@ -91,8 +94,7 @@ def get_version():
 @click.group(cls=ProxyToWranglerGroup)
 @click.option("--debug", is_flag=True, help="Enable debug logging")
 @click.version_option(version=get_version(), prog_name="pywrangler")
-@click.pass_context
-def app(ctx, debug=False):
+def app(debug: bool = False) -> None:
     """
     A CLI tool for Cloudflare Workers.
     Use 'sync' command for Python package setup.
@@ -118,7 +120,7 @@ def app(ctx, debug=False):
     type=click.Path(exists=True, dir_okay=False, readable=True),
     help="Path to Wrangler configuration file",
 )
-def types_command(outdir=None, config=None):
+def types_command(outdir: str | None, config: str | None) -> Never:
     from .types import wrangler_types
 
     wrangler_types(outdir, config)
@@ -127,56 +129,17 @@ def types_command(outdir=None, config=None):
 
 @app.command("sync")
 @click.option("--force", is_flag=True, help="Force sync even if no changes detected")
-def sync_command(force=False, directly_requested=True):
+def sync_command(force: bool = False) -> None:
     """
     Installs Python packages from pyproject.toml into src/vendor.
 
     Also creates a virtual env for Workers that you can use for testing.
     """
-    # This module is imported locally because it searches for pyproject.toml at the top-level.
-    from .sync import (
-        check_requirements_txt,
-        check_wrangler_config,
-        is_sync_needed,
-        create_pyodide_venv,
-        create_workers_venv,
-        parse_requirements,
-        install_requirements,
-    )
-
-    # Check if requirements.txt does not exist.
-    check_requirements_txt()
-
-    # Check if sync is needed based on file timestamps
-    sync_needed = force or is_sync_needed()
-    if not sync_needed:
-        if directly_requested:
-            logger.warning(
-                "pyproject.toml hasn't changed since last sync, use --force to ignore timestamp check"
-            )
-        return
-
-    # Check to make sure a wrangler config file exists.
-    check_wrangler_config()
-
-    # Create .venv-workers if it doesn't exist
-    create_workers_venv()
-
-    # Set up Pyodide virtual env
-    create_pyodide_venv()
-
-    # Generate requirements.txt from pyproject.toml by directly parsing the TOML file then install into vendor folder.
-    requirements = parse_requirements()
-    if not requirements:
-        logger.warning(
-            "No dependencies found in [project.dependencies] section of pyproject.toml."
-        )
-    install_requirements(requirements)
-
+    sync(force, directly_requested=True)
     write_success("Sync process completed successfully.")
 
 
-def _proxy_to_wrangler(command_name, args_list):
+def _proxy_to_wrangler(command_name: str, args_list: list[str]) -> Never:
     command_to_run = WRANGLER_COMMAND + [command_name] + args_list
     logger.info(f"Passing command to npx wrangler: {' '.join(command_to_run)}")
     try:
@@ -189,7 +152,7 @@ def _proxy_to_wrangler(command_name, args_list):
         click.get_current_context().exit(1)
 
 
-def _proxy_to_create_cloudflare(args_list):
+def _proxy_to_create_cloudflare(args_list: list[str]) -> Never:
     command_to_run = WRANGLER_CREATE_COMMAND + args_list
     logger.info(f"Passing command to npx create-cloudflare: {' '.join(command_to_run)}")
     try:

pywrangler/metadata.py

@@ -1,5 +1,5 @@
-from typing import Literal, NamedTuple
 from datetime import datetime
+from typing import Literal, NamedTuple
 
 
 class PythonCompatVersion(NamedTuple):

pywrangler/sync.py

@@ -1,43 +1,48 @@
 import logging
 import os
-import re
 import shutil
 import tempfile
+from collections.abc import Iterator
 from contextlib import contextmanager
-from datetime import datetime
 from pathlib import Path
-from typing import Literal
 
 import click
-import pyjson5
 
 from .utils import (
-    run_command,
+    check_uv_version,
+    check_wrangler_config,
     find_pyproject_toml,
+    get_project_root,
+    get_pyodide_index,
+    get_python_version,
+    get_uv_pyodide_interp_name,
+    read_pyproject_toml,
+    run_command,
 )
-from .metadata import PYTHON_COMPAT_VERSIONS
-
-try:
-    import tomllib  # Standard in Python 3.11+
-except ImportError:
-    import tomli as tomllib  # For Python < 3.11
 
 logger = logging.getLogger(__name__)
 
-# Define paths
-PYPROJECT_TOML_PATH = find_pyproject_toml()
-PROJECT_ROOT = PYPROJECT_TOML_PATH.parent
-VENV_WORKERS_PATH = PROJECT_ROOT / ".venv-workers"
-VENV_WORKERS_TOKEN = PROJECT_ROOT / ".venv-workers/.synced"
-PYODIDE_VENV_PATH = VENV_WORKERS_PATH / "pyodide-venv"
-VENDOR_TOKEN = PROJECT_ROOT / "python_modules/.synced"
-VENV_REQUIREMENTS_PATH = VENV_WORKERS_PATH / "temp-venv-requirements.txt"
+
+def get_venv_workers_path() -> Path:
+    return get_project_root() / ".venv-workers"
+
+
+def get_venv_workers_token_path() -> Path:
+    return get_venv_workers_path() / ".synced"
 
 
-def check_requirements_txt():
-    old_requirements_txt = PROJECT_ROOT / "requirements.txt"
+def get_vendor_token_path() -> Path:
+    return get_project_root() / "python_modules/.synced"
+
+
+def get_pyodide_venv_path() -> Path:
+    return get_venv_workers_path() / "pyodide-venv"
+
+
+def check_requirements_txt() -> None:
+    old_requirements_txt = get_project_root() / "requirements.txt"
     if old_requirements_txt.is_file():
-        with open(old_requirements_txt, "r") as f:
+        with open(old_requirements_txt) as f:
             requirements = f.read().splitlines()
             logger.warning(
                 "Specifying Python Packages in requirements.txt is no longer supported, please use pyproject.toml instead.\n"
@@ -54,118 +59,6 @@ def check_requirements_txt():
         raise click.exceptions.Exit(code=1)
 
 
-def check_wrangler_config():
-    wrangler_jsonc = PROJECT_ROOT / "wrangler.jsonc"
-    wrangler_toml = PROJECT_ROOT / "wrangler.toml"
-    if not wrangler_jsonc.is_file() and not wrangler_toml.is_file():
-        logger.error(
-            f"{wrangler_jsonc} or {wrangler_toml} not found in {PROJECT_ROOT}."
-        )
-        raise click.exceptions.Exit(code=1)
-
-
-def _parse_wrangler_config() -> dict:
-    """
-    Parse wrangler configuration from either wrangler.toml or wrangler.jsonc.
-
-    Returns:
-        dict: Parsed configuration data
-    """
-    wrangler_toml = PROJECT_ROOT / "wrangler.toml"
-    wrangler_jsonc = PROJECT_ROOT / "wrangler.jsonc"
-
-    if wrangler_toml.is_file():
-        try:
-            with open(wrangler_toml, "rb") as f:
-                return tomllib.load(f)
-        except tomllib.TOMLDecodeError as e:
-            logger.error(f"Error parsing {wrangler_toml}: {e}")
-            raise click.exceptions.Exit(code=1)
-
-    if wrangler_jsonc.is_file():
-        try:
-            with open(wrangler_jsonc, "r") as f:
-                content = f.read()
-            return pyjson5.loads(content)
-        except (pyjson5.Json5DecoderError, ValueError) as e:
-            logger.error(f"Error parsing {wrangler_jsonc}: {e}")
-            raise click.exceptions.Exit(code=1)
-
-    return {}
-
-
-def _get_python_version() -> Literal["3.12", "3.13"]:
-    """
-    Determine Python version from wrangler configuration.
-
-    Returns:
-        Python version string
-    """
-    config = _parse_wrangler_config()
-
-    if not config:
-        logger.error("No wrangler config found")
-        raise click.exceptions.Exit(code=1)
-
-    compat_flags = config.get("compatibility_flags", [])
-
-    if "compatibility_date" not in config:
-        logger.error("No compatibility_date specified in wrangler config")
-        raise click.exceptions.Exit(code=1)
-    try:
-        compat_date = datetime.strptime(config.get("compatibility_date"), "%Y-%m-%d")
-    except ValueError:
-        logger.error(
-            f"Invalid compatibility_date format: {config.get('compatibility_date')}"
-        )
-        raise click.exceptions.Exit(code=1)
-
-    # Check if python_workers base flag is present (required for Python workers)
-    if "python_workers" not in compat_flags:
-        logger.error("`python_workers` compat flag not specified in wrangler config")
-        raise click.exceptions.Exit(code=1)
-
-    # Find the most specific Python version based on compat flags and date
-    # Sort by version descending to prioritize newer versions
-    sorted_versions = sorted(
-        PYTHON_COMPAT_VERSIONS, key=lambda x: x.version, reverse=True
-    )
-
-    for py_version in sorted_versions:
-        # Check if the specific compat flag is present
-        if py_version.compat_flag in compat_flags:
-            return py_version.version
-
-        # For versions with compat_date, also check the date requirement
-        if (
-            py_version.compat_date
-            and compat_date
-            and compat_date >= py_version.compat_date
-        ):
-            return py_version.version
-
-    logger.error("Could not determine Python version from wrangler config")
-    raise click.exceptions.Exit(code=1)
-
-
-def _get_uv_pyodide_interp_name():
-    match _get_python_version():
-        case "3.12":
-            v = "3.12.7"
-        case "3.13":
-            v = "3.13.2"
-    return f"cpython-{v}-emscripten-wasm32-musl"
-
-
-def _get_pyodide_index():
-    match _get_python_version():
-        case "3.12":
-            v = "0.27.7"
-        case "3.13":
-            v = "0.28.3"
-    return "https://index.pyodide.org/" + v
-
-
 def _get_venv_python_version() -> str | None:
     """
     Retrieves the Python version from the virtual environment.
@@ -173,10 +66,11 @@ def _get_venv_python_version() -> str | None:
     Returns:
         The Python version string or None if it cannot be determined.
     """
+    venv_workers_path = get_venv_workers_path()
     venv_python = (
-        VENV_WORKERS_PATH / "Scripts" / "python.exe"
+        venv_workers_path / "Scripts" / "python.exe"
         if os.name == "nt"
-        else VENV_WORKERS_PATH / "bin" / "python"
+        else venv_workers_path / "bin" / "python"
     )
     if not venv_python.is_file():
         return None
@@ -190,136 +84,74 @@ def _get_venv_python_version() -> str | None:
     return result.stdout.strip()
 
 
-def create_workers_venv():
+def create_workers_venv() -> None:
     """
-    Creates a virtual environment at `VENV_WORKERS_PATH` if it doesn't exist.
+    Creates a virtual environment at `venv_workers_path` if it doesn't exist.
     """
-    wanted_python_version = _get_python_version()
+    wanted_python_version = get_python_version()
     logger.debug(f"Using python version from wrangler config: {wanted_python_version}")
 
-    if VENV_WORKERS_PATH.is_dir():
+    venv_workers_path = get_venv_workers_path()
+    if venv_workers_path.is_dir():
         installed_version = _get_venv_python_version()
         if installed_version:
             if wanted_python_version in installed_version:
                 logger.debug(
-                    f"Virtual environment at {VENV_WORKERS_PATH} already exists."
+                    f"Virtual environment at {venv_workers_path} already exists."
                 )
                 return
 
             logger.warning(
-                f"Recreating virtual environment at {VENV_WORKERS_PATH} due to Python version mismatch. "
+                f"Recreating virtual environment at {venv_workers_path} due to Python version mismatch. "
                 f"Found {installed_version}, expected {wanted_python_version}"
             )
         else:
             logger.warning(
-                f"Could not determine python version for {VENV_WORKERS_PATH}, recreating."
+                f"Could not determine python version for {venv_workers_path}, recreating."
             )
 
-        shutil.rmtree(VENV_WORKERS_PATH)
+        shutil.rmtree(venv_workers_path)
 
-    logger.debug(f"Creating virtual environment at {VENV_WORKERS_PATH}...")
+    logger.debug(f"Creating virtual environment at {venv_workers_path}...")
     run_command(
         [
             "uv",
             "venv",
-            str(VENV_WORKERS_PATH),
+            str(venv_workers_path),
             "--python",
             f"python{wanted_python_version}",
         ]
     )
 
 
-MIN_UV_VERSION = (0, 8, 10)
-MIN_WRANGLER_VERSION = (4, 42, 1)
-
-
-def check_uv_version():
-    res = run_command(["uv", "--version"], capture_output=True)
-    ver_str = res.stdout.split(" ")[1]
-    ver = tuple(int(x) for x in ver_str.split("."))
-    if ver >= MIN_UV_VERSION:
-        return
-    min_version_str = ".".join(str(x) for x in MIN_UV_VERSION)
-    logger.error(f"uv version at least {min_version_str} required, have {ver_str}.")
-    logger.error("Update uv with `uv self update`.")
-    raise click.exceptions.Exit(code=1)
-
-
-def check_wrangler_version():
-    """
-    Check that the installed wrangler version is at least 4.42.1.
-
-    Raises:
-        click.exceptions.Exit: If wrangler is not installed or version is too old.
-    """
-    result = run_command(
-        ["npx", "--yes", "wrangler", "--version"], capture_output=True, check=False
-    )
-    if result.returncode != 0:
-        logger.error("Failed to get wrangler version. Is wrangler installed?")
-        logger.error("Install wrangler with: npm install wrangler@latest")
-        raise click.exceptions.Exit(code=1)
-
-    # Parse version from output like "wrangler 4.42.1" or " ⛅️ wrangler 4.42.1"
-    version_line = result.stdout.strip()
-    # Extract version number using regex
-    version_match = re.search(r"(\d+)\.(\d+)\.(\d+)", version_line)
-
-    if not version_match:
-        logger.error(f"Could not parse wrangler version from: {version_line}")
-        logger.error("Install wrangler with: npm install wrangler@latest")
-        raise click.exceptions.Exit(code=1)
-
-    major, minor, patch = map(int, version_match.groups())
-    current_version = (major, minor, patch)
-
-    if current_version < MIN_WRANGLER_VERSION:
-        min_version_str = ".".join(str(x) for x in MIN_WRANGLER_VERSION)
-        current_version_str = ".".join(str(x) for x in current_version)
-        logger.error(
-            f"wrangler version at least {min_version_str} required, have {current_version_str}."
-        )
-        logger.error("Update wrangler with: npm install wrangler@latest")
-        raise click.exceptions.Exit(code=1)
-
-    logger.debug(
-        f"wrangler version {'.'.join(str(x) for x in current_version)} is sufficient"
-    )
-
-
-def create_pyodide_venv():
-    if PYODIDE_VENV_PATH.is_dir():
+def create_pyodide_venv() -> None:
+    pyodide_venv_path = get_pyodide_venv_path()
+    if pyodide_venv_path.is_dir():
         logger.debug(
-            f"Pyodide virtual environment at {PYODIDE_VENV_PATH} already exists."
+            f"Pyodide virtual environment at {pyodide_venv_path} already exists."
         )
         return
 
     check_uv_version()
-    logger.debug(f"Creating Pyodide virtual environment at {PYODIDE_VENV_PATH}...")
-    PYODIDE_VENV_PATH.parent.mkdir(parents=True, exist_ok=True)
-    interp_name = _get_uv_pyodide_interp_name()
+    logger.debug(f"Creating Pyodide virtual environment at {pyodide_venv_path}...")
+    pyodide_venv_path.parent.mkdir(parents=True, exist_ok=True)
+    interp_name = get_uv_pyodide_interp_name()
     run_command(["uv", "python", "install", interp_name])
-    run_command(["uv", "venv", PYODIDE_VENV_PATH, "--python", interp_name])
+    run_command(["uv", "venv", pyodide_venv_path, "--python", interp_name])
 
 
 def parse_requirements() -> list[str]:
-    logger.debug(f"Reading dependencies from {PYPROJECT_TOML_PATH}...")
-    try:
-        with open(PYPROJECT_TOML_PATH, "rb") as f:
-            pyproject_data = tomllib.load(f)
-
-        # Extract dependencies from [project.dependencies]
-        dependencies = pyproject_data.get("project", {}).get("dependencies", [])
-
-        logger.info(f"Found {len(dependencies)} dependencies.")
-        return dependencies
-    except tomllib.TOMLDecodeError as e:
-        logger.error(f"Error parsing {PYPROJECT_TOML_PATH}: {str(e)}")
-        raise click.exceptions.Exit(code=1)
+    pyproject_data = read_pyproject_toml()
+
+    # Extract dependencies from [project.dependencies]
+    dependencies = pyproject_data.get("project", {}).get("dependencies", [])
+
+    logger.info(f"Found {len(dependencies)} dependencies.")
+    return dependencies
 
 
 @contextmanager
-def temp_requirements_file(requirements: list[str]):
+def temp_requirements_file(requirements: list[str]) -> Iterator[str]:
     # Write dependencies to a requirements.txt-style temp file.
     with tempfile.NamedTemporaryFile(mode="w", suffix=".txt") as temp_file:
         temp_file.write("\n".join(requirements))
@@ -327,8 +159,8 @@ def temp_requirements_file(requirements: list[str]):
         yield temp_file.name
 
 
-def _install_requirements_to_vendor(requirements: list[str]):
-    vendor_path = PROJECT_ROOT / "python_modules"
+def _install_requirements_to_vendor(requirements: list[str]) -> None:
+    vendor_path = get_project_root() / "python_modules"
     logger.debug(f"Using vendor path: {vendor_path}")
 
     if len(requirements) == 0:
@@ -339,13 +171,13 @@ def _install_requirements_to_vendor(requirements: list[str]):
 
     # Install packages into vendor directory
     vendor_path.mkdir(parents=True, exist_ok=True)
-    relative_vendor_path = vendor_path.relative_to(PROJECT_ROOT)
+    relative_vendor_path = vendor_path.relative_to(get_project_root())
     logger.info(
         f"Installing packages into [bold]{relative_vendor_path}[/bold]...",
         extra={"markup": True},
     )
     with temp_requirements_file(requirements) as requirements_file:
-        run_command(
+        result = run_command(
             [
                 "uv",
                 "pip",
@@ -354,21 +186,44 @@ def _install_requirements_to_vendor(requirements: list[str]):
                 "-r",
                 requirements_file,
                 "--extra-index-url",
-                _get_pyodide_index(),
+                get_pyodide_index(),
                 "--index-strategy",
                 "unsafe-best-match",
             ],
-            env=os.environ | {"VIRTUAL_ENV": PYODIDE_VENV_PATH},
+            capture_output=True,
+            check=False,
+            env=os.environ | {"VIRTUAL_ENV": get_pyodide_venv_path()},
         )
-        pyv = _get_python_version()
+        if result.returncode != 0:
+            logger.warning(result.stdout.strip())
+            # Handle some common failures and give nicer error messages for them.
+            lowered_stdout = result.stdout.lower()
+            if "invalid peer certificate" in lowered_stdout:
+                logger.error(
+                    "Installation failed because of an invalid peer certificate. Are your systems certificates correctly installed? Do you have an Enterprise VPN enabled?"
+                )
+            elif "failed to fetch" in lowered_stdout:
+                logger.error(
+                    "Installation failed because of a failed fetch. Is your network connection working?"
+                )
+            elif "no solution found when resolving dependencies" in lowered_stdout:
+                logger.error(
+                    "Installation failed because the packages you requested are not supported by Python Workers. See above for details."
+                )
+            else:
+                logger.error(
+                    "Installation of packages into the Python Worker failed. Possibly because these packages are not currently supported. See above for details."
+                )
+            raise click.exceptions.Exit(code=result.returncode)
+        pyv = get_python_version()
         shutil.rmtree(vendor_path)
         shutil.copytree(
-            PYODIDE_VENV_PATH / f"lib/python{pyv}/site-packages", vendor_path
+            get_pyodide_venv_path() / f"lib/python{pyv}/site-packages", vendor_path
         )
 
     # Create a pyvenv.cfg file in python_modules to mark it as a virtual environment
     (vendor_path / "pyvenv.cfg").touch()
-    VENDOR_TOKEN.touch()
+    get_vendor_token_path().touch()
 
     logger.info(
         f"Packages installed in [bold]{relative_vendor_path}[/bold].",
@@ -376,9 +231,11 @@ def _install_requirements_to_vendor(requirements: list[str]):
     )
 
 
-def _install_requirements_to_venv(requirements: list[str]):
+def _install_requirements_to_venv(requirements: list[str]) -> None:
     # Create a requirements file for .venv-workers that includes pyodide-py
-    relative_venv_workers_path = VENV_WORKERS_PATH.relative_to(PROJECT_ROOT)
+    venv_workers_path = get_venv_workers_path()
+    project_root = get_project_root()
+    relative_venv_workers_path = venv_workers_path.relative_to(project_root)
     requirements = requirements.copy()
     requirements.append("pyodide-py")
 
@@ -387,7 +244,7 @@ def _install_requirements_to_venv(requirements: list[str]):
         extra={"markup": True},
     )
     with temp_requirements_file(requirements) as requirements_file:
-        run_command(
+        result = run_command(
             [
                 "uv",
                 "pip",
@@ -395,18 +252,33 @@ def _install_requirements_to_venv(requirements: list[str]):
                 "-r",
                 requirements_file,
             ],
-            env=os.environ | {"VIRTUAL_ENV": VENV_WORKERS_PATH},
+            check=False,
+            env=os.environ | {"VIRTUAL_ENV": venv_workers_path},
+            capture_output=True,
         )
-    VENV_WORKERS_TOKEN.touch()
+        if result.returncode != 0:
+            logger.warning(result.stdout.strip())
+            logger.error(
+                "Failed to install the requirements defined in your pyproject.toml file. See above for details."
+            )
+            raise click.exceptions.Exit(code=result.returncode)
+
+    get_venv_workers_token_path().touch()
     logger.info(
         f"Packages installed in [bold]{relative_venv_workers_path}[/bold].",
         extra={"markup": True},
     )
 
 
-def install_requirements(requirements: list[str]):
-    _install_requirements_to_vendor(requirements)
+def install_requirements(requirements: list[str]) -> None:
+    # Note: the order these are executed is important.
+    # We need to install to .venv-workers first, so that we can determine if the packages requested
+    # by the user are valid.
     _install_requirements_to_venv(requirements)
+    # Then we install the same requirements to the vendor directory. If this installation
+    # fails while the above succeeded, it implies that Pyodide does not support these package
+    # requirements which allows us to give a nicer error message to the user.
+    _install_requirements_to_vendor(requirements)
 
 
 def _is_out_of_date(token: Path, time: float) -> bool:
@@ -415,19 +287,50 @@ def _is_out_of_date(token: Path, time: float) -> bool:
     return time > token.stat().st_mtime
 
 
-def is_sync_needed():
+def is_sync_needed() -> bool:
     """
     Checks if pyproject.toml has been modified since the last sync.
 
     Returns:
         bool: True if sync is needed, False otherwise
     """
-
-    if not PYPROJECT_TOML_PATH.is_file():
+    pyproject_toml_path = find_pyproject_toml()
+    if not pyproject_toml_path.is_file():
         # If pyproject.toml doesn't exist, we need to abort anyway
         return True
 
-    pyproject_mtime = PYPROJECT_TOML_PATH.stat().st_mtime
-    return _is_out_of_date(VENDOR_TOKEN, pyproject_mtime) or _is_out_of_date(
-        VENV_WORKERS_TOKEN, pyproject_mtime
+    pyproject_mtime = pyproject_toml_path.stat().st_mtime
+    return _is_out_of_date(get_vendor_token_path(), pyproject_mtime) or _is_out_of_date(
+        get_venv_workers_token_path(), pyproject_mtime
     )
+
+
+def sync(force: bool = False, directly_requested: bool = False) -> None:
+    # Check if requirements.txt does not exist.
+    check_requirements_txt()
+
+    # Check if sync is needed based on file timestamps
+    sync_needed = force or is_sync_needed()
+    if not sync_needed:
+        if directly_requested:
+            logger.warning(
+                "pyproject.toml hasn't changed since last sync, use --force to ignore timestamp check"
+            )
+        return
+
+    # Check to make sure a wrangler config file exists.
+    check_wrangler_config()
+
+    # Create .venv-workers if it doesn't exist
+    create_workers_venv()
+
+    # Set up Pyodide virtual env
+    create_pyodide_venv()
+
+    # Generate requirements.txt from pyproject.toml by directly parsing the TOML file then install into vendor folder.
+    requirements = parse_requirements()
+    if not requirements:
+        logger.warning(
+            "No dependencies found in [project.dependencies] section of pyproject.toml."
+        )
+    install_requirements(requirements)

pywrangler/types.py

@@ -1,7 +1,8 @@
-from .utils import WRANGLER_COMMAND, run_command
-from tempfile import TemporaryDirectory
-from pathlib import Path
 import logging
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from .utils import WRANGLER_COMMAND, run_command
 
 logger = logging.getLogger(__name__)
 
@@ -26,7 +27,7 @@ PACKAGE_JSON = """
 """
 
 
-def wrangler_types(outdir_arg: str | None, config: str | None, /):
+def wrangler_types(outdir_arg: str | None, config: str | None, /) -> None:
     args = ["types"]
     if config:
         args += ["--config", config]

pywrangler/utils.py

@@ -1,11 +1,20 @@
 import logging
+import re
 import subprocess
+import tomllib
+from datetime import datetime
+from functools import cache
 from pathlib import Path
+from typing import Literal, TypedDict, cast
 
 import click
-from rich.logging import Console, RichHandler
+import pyjson5
+from rich.console import Console
+from rich.logging import RichHandler
 from rich.theme import Theme
 
+from .metadata import PYTHON_COMPAT_VERSIONS
+
 WRANGLER_COMMAND = ["npx", "--yes", "wrangler"]
 WRANGLER_CREATE_COMMAND = ["npx", "--yes", "create-cloudflare"]
 
@@ -16,7 +25,7 @@ RUNNING_LEVEL = 15
 OUTPUT_LEVEL = 16
 
 
-def setup_logging():
+def setup_logging() -> None:
     console = Console(
         theme=Theme(
             {
@@ -44,17 +53,17 @@ def setup_logging():
     logging.addLevelName(OUTPUT_LEVEL, "OUTPUT")
 
 
-def write_success(msg):
+def write_success(msg: str) -> None:
     logging.log(SUCCESS_LEVEL, msg)
 
 
 def run_command(
     command: list[str | Path],
     cwd: Path | None = None,
-    env: dict | None = None,
+    env: dict[str, str | Path] | None = None,
     check: bool = True,
     capture_output: bool = False,
-):
+) -> subprocess.CompletedProcess[str]:
     """
     Runs a command and handles logging and errors.
 
@@ -70,27 +79,32 @@ def run_command(
     """
     logger.log(RUNNING_LEVEL, f"{' '.join(str(arg) for arg in command)}")
     try:
+        kwargs = {}
+        if capture_output:
+            kwargs = dict(stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+
         process = subprocess.run(
             command,
             cwd=cwd,
             env=env,
             check=check,
-            capture_output=capture_output,
             text=True,
-        )
+            **kwargs,
+        )  # type: ignore[call-overload]
         if process.stdout and not capture_output:
             logger.log(OUTPUT_LEVEL, f"{process.stdout.strip()}")
-        return process
+        return process  # type: ignore[no-any-return]
     except subprocess.CalledProcessError as e:
         logger.error(
-            f"Error running command: {' '.join(str(arg) for arg in command)}\nExit code: {e.returncode}\nOutput:\n{e.stdout.strip() if e.stdout else ''}{e.stderr.strip() if e.stderr else ''}"
+            f"Error running command: {' '.join(str(arg) for arg in command)}\nExit code: {e.returncode}\nOutput:\n{e.stdout.strip() if e.stdout else ''}"
         )
-        raise click.exceptions.Exit(code=e.returncode)
+        raise click.exceptions.Exit(code=e.returncode) from None
     except FileNotFoundError:
         logger.error(f"Command not found: {command[0]}. Is it installed and in PATH?")
-        raise click.exceptions.Exit(code=1)
+        raise click.exceptions.Exit(code=1) from None
 
 
+@cache
 def find_pyproject_toml() -> Path:
     """
     Search for pyproject.toml starting from current working directory and going up the directory tree.
@@ -112,3 +126,200 @@ def find_pyproject_toml() -> Path:
         f"pyproject.toml not found in {Path.cwd().resolve()} or any parent directories"
     )
     raise click.exceptions.Exit(code=1)
+
+
+class PyProjectProject(TypedDict):
+    dependencies: list[str]
+
+
+class PyProject(TypedDict):
+    project: PyProjectProject
+
+
+def read_pyproject_toml() -> PyProject:
+    pyproject_toml = find_pyproject_toml()
+    logger.debug(f"Reading {pyproject_toml}...")
+    try:
+        with open(pyproject_toml, "rb") as f:
+            return cast(PyProject, tomllib.load(f))
+    except tomllib.TOMLDecodeError as e:
+        logger.error(f"Error parsing {pyproject_toml}: {str(e)}")
+        raise click.exceptions.Exit(code=1) from None
+
+
+def get_project_root() -> Path:
+    return find_pyproject_toml().parent
+
+
+MIN_UV_VERSION = (0, 8, 10)
+MIN_WRANGLER_VERSION = (4, 42, 1)
+
+
+def check_uv_version() -> None:
+    res = run_command(["uv", "--version"], capture_output=True)
+    ver_str = res.stdout.split(" ")[1]
+    ver = tuple(int(x) for x in ver_str.split("."))
+    if ver >= MIN_UV_VERSION:
+        return
+    min_version_str = ".".join(str(x) for x in MIN_UV_VERSION)
+    logger.error(f"uv version at least {min_version_str} required, have {ver_str}.")
+    logger.error("Update uv with `uv self update`.")
+    raise click.exceptions.Exit(code=1)
+
+
+def check_wrangler_version() -> None:
+    """
+    Check that the installed wrangler version is at least 4.42.1.
+
+    Raises:
+        click.exceptions.Exit: If wrangler is not installed or version is too old.
+    """
+    result = run_command(
+        ["npx", "--yes", "wrangler", "--version"], capture_output=True, check=False
+    )
+    if result.returncode != 0:
+        logger.error("Failed to get wrangler version. Is wrangler installed?")
+        logger.error("Install wrangler with: npm install wrangler@latest")
+        raise click.exceptions.Exit(code=1)
+
+    # Parse version from output like "wrangler 4.42.1" or " ⛅️ wrangler 4.42.1"
+    version_line = result.stdout.strip()
+    # Extract version number using regex
+    version_match = re.search(r"(\d+)\.(\d+)\.(\d+)", version_line)
+
+    if not version_match:
+        logger.error(f"Could not parse wrangler version from: {version_line}")
+        logger.error("Install wrangler with: npm install wrangler@latest")
+        raise click.exceptions.Exit(code=1)
+
+    major, minor, patch = map(int, version_match.groups())
+    current_version = (major, minor, patch)
+
+    if current_version < MIN_WRANGLER_VERSION:
+        min_version_str = ".".join(str(x) for x in MIN_WRANGLER_VERSION)
+        current_version_str = ".".join(str(x) for x in current_version)
+        logger.error(
+            f"wrangler version at least {min_version_str} required, have {current_version_str}."
+        )
+        logger.error("Update wrangler with: npm install wrangler@latest")
+        raise click.exceptions.Exit(code=1)
+
+    logger.debug(
+        f"wrangler version {'.'.join(str(x) for x in current_version)} is sufficient"
+    )
+
+
+def check_wrangler_config() -> None:
+    PROJECT_ROOT = get_project_root()
+    wrangler_jsonc = PROJECT_ROOT / "wrangler.jsonc"
+    wrangler_toml = PROJECT_ROOT / "wrangler.toml"
+    if not wrangler_jsonc.is_file() and not wrangler_toml.is_file():
+        logger.error(
+            f"{wrangler_jsonc} or {wrangler_toml} not found in {PROJECT_ROOT}."
+        )
+        raise click.exceptions.Exit(code=1)
+
+
+class WranglerConfig(TypedDict, total=False):
+    compatibility_date: str
+    compatibility_flags: list[str]
+
+
+def _parse_wrangler_config() -> WranglerConfig:
+    """
+    Parse wrangler configuration from either wrangler.toml or wrangler.jsonc.
+
+    Returns:
+        dict: Parsed configuration data
+    """
+    PROJECT_ROOT = get_project_root()
+    wrangler_toml = PROJECT_ROOT / "wrangler.toml"
+    wrangler_jsonc = PROJECT_ROOT / "wrangler.jsonc"
+
+    if wrangler_toml.is_file():
+        try:
+            with open(wrangler_toml, "rb") as f:
+                return cast(WranglerConfig, tomllib.load(f))
+        except tomllib.TOMLDecodeError as e:
+            logger.error(f"Error parsing {wrangler_toml}: {e}")
+            raise click.exceptions.Exit(code=1) from None
+
+    if wrangler_jsonc.is_file():
+        try:
+            with open(wrangler_jsonc) as f:
+                content = f.read()
+            return cast(WranglerConfig, pyjson5.loads(content))
+        except (pyjson5.Json5DecoderException, ValueError) as e:
+            logger.error(f"Error parsing {wrangler_jsonc}: {e}")
+            raise click.exceptions.Exit(code=1) from None
+
+    return {}
+
+
+@cache
+def get_python_version() -> Literal["3.12", "3.13"]:
+    """
+    Determine Python version from wrangler configuration.
+
+    Returns:
+        Python version string
+    """
+    config = _parse_wrangler_config()
+
+    if not config:
+        logger.error("No wrangler config found")
+        raise click.exceptions.Exit(code=1)
+
+    compat_flags = config.get("compatibility_flags", [])
+    compat_date_str = config.get("compatibility_date", None)
+    if compat_date_str is None:
+        logger.error("No compatibility_date specified in wrangler config")
+        raise click.exceptions.Exit(code=1)
+    try:
+        compat_date = datetime.strptime(compat_date_str, "%Y-%m-%d")
+    except ValueError:
+        logger.error(
+            f"Invalid compatibility_date format: {config.get('compatibility_date')}"
+        )
+        raise click.exceptions.Exit(code=1) from None
+
+    # Check if python_workers base flag is present (required for Python workers)
+    if "python_workers" not in compat_flags:
+        logger.error("`python_workers` compat flag not specified in wrangler config")
+        raise click.exceptions.Exit(code=1)
+
+    # Find the most specific Python version based on compat flags and date
+    # Sort by version descending to prioritize newer versions
+    sorted_versions = sorted(
+        PYTHON_COMPAT_VERSIONS, key=lambda x: x.version, reverse=True
+    )
+
+    for py_version in sorted_versions:
+        # Check if the specific compat flag is present
+        if py_version.compat_flag in compat_flags:
+            return py_version.version
+
+        # For versions with compat_date, also check the date requirement
+        if py_version.compat_date and compat_date >= py_version.compat_date:
+            return py_version.version
+
+    logger.error("Could not determine Python version from wrangler config")
+    raise click.exceptions.Exit(code=1)
+
+
+def get_uv_pyodide_interp_name() -> str:
+    match get_python_version():
+        case "3.12":
+            v = "3.12.7"
+        case "3.13":
+            v = "3.13.2"
+    return f"cpython-{v}-emscripten-wasm32-musl"
+
+
+def get_pyodide_index() -> str:
+    match get_python_version():
+        case "3.12":
+            v = "0.27.7"
+        case "3.13":
+            v = "0.28.3"
+    return "https://index.pyodide.org/" + v

{workers_py-1.6.1.dist-info → workers_py-1.7.0.dist-info}/METADATA

@@ -1,18 +1,19 @@
 Metadata-Version: 2.4
 Name: workers-py
-Version: 1.6.1
+Version: 1.7.0
 Summary: A set of libraries and tools for Python Workers
 Project-URL: Homepage, https://github.com/cloudflare/workers-py
 Project-URL: Bug Tracker, https://github.com/cloudflare/workers-py/issues
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.10
+Requires-Python: >=3.12
 Requires-Dist: click<9.0.0,>=8.0.0
 Requires-Dist: pyjson5>=1.6.0
 Requires-Dist: pyodide-cli
 Requires-Dist: pyodide-py
 Requires-Dist: rich>=13.0.0
+Requires-Dist: workers-runtime-sdk>=0.1.0
 Provides-Extra: build
 Requires-Dist: uv~=0.5.23; extra == 'build'
 Description-Content-Type: text/markdown

workers_py-1.7.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+pywrangler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pywrangler/__main__.py,sha256=wcCrL4PjG51r5wVKqJhcoJPTLfHW0wNbD31DrUN0MWI,28
+pywrangler/cli.py,sha256=8C4iBntruyMkQqOb0KfH_H0QNGYYWEBtKFA7b7zGSmE,5467
+pywrangler/metadata.py,sha256=ndh584ALzshSXwduTmqVczfF5Mpn7z0F9ztn3Dugf70,408
+pywrangler/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pywrangler/sync.py,sha256=TuM_bmBdgi37xYFtD62GTNwyNaDgO87QwfS-OYLR8OM,11647
+pywrangler/types.py,sha256=hYJ6hNIjWb0faBGW82AWfCBsF_JPb7sXKCXPtFM3Mhk,1183
+pywrangler/utils.py,sha256=mPY8LcRqYMuyVzyWS_077-4MX3K6sIThV1gY8_br9U0,10495
+workers_py-1.7.0.dist-info/METADATA,sha256=z6R2A_5LLb2hE5xY6NOpqXxX0ooA3kexOp1BIho7qlc,1774
+workers_py-1.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+workers_py-1.7.0.dist-info/entry_points.txt,sha256=pt6X-Nv5-gSiKUwrnvLwzlSXs9yP37m7zdTAi8f6nAM,50
+workers_py-1.7.0.dist-info/RECORD,,

workers_py-1.6.1.dist-info/RECORD

@@ -1,11 +0,0 @@
-pywrangler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pywrangler/__main__.py,sha256=wcCrL4PjG51r5wVKqJhcoJPTLfHW0wNbD31DrUN0MWI,28
-pywrangler/cli.py,sha256=voUaP2tHCwxznzZ45O6ZAJ91vbp6q9UNb7H2OlgnZ_k,6596
-pywrangler/metadata.py,sha256=vttmaCtouSr9ADj8ncvNGqeaWEGFP8pamH2T6ohFjnA,408
-pywrangler/sync.py,sha256=fFavYhbvBXF4memxrJLnMJpApET_3fx9NmJ_O6NDzxw,14217
-pywrangler/types.py,sha256=RyOTVFFC75vJ0NxGzXWJGouRpQ5k4gsf3Jsiq-i_ans,1174
-pywrangler/utils.py,sha256=JOPCXy_O_RZ-ClSSWL5pel2Iltyclj_JV13IxKr_WRo,3382
-workers_py-1.6.1.dist-info/METADATA,sha256=0oipVsEgOgZhdUXJp9ckB7HWqGVvqqsh2sbcQBL1yIY,1732
-workers_py-1.6.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-workers_py-1.6.1.dist-info/entry_points.txt,sha256=pt6X-Nv5-gSiKUwrnvLwzlSXs9yP37m7zdTAi8f6nAM,50
-workers_py-1.6.1.dist-info/RECORD,,