workers-py 1.6.1__tar.gz → 1.7.0__tar.gz

{workers_py-1.6.1 → workers_py-1.7.0}/.pre-commit-config.yaml

@@ -37,5 +37,12 @@ repos:
             "--ignore-words-list",
             "ommit",
           ]
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: "v1.14.1"
+    hooks:
+      - id: mypy
+        exclude: (.*test.*)
+        additional_dependencies:
+          - click
 ci:
   autoupdate_schedule: "quarterly"

{workers_py-1.6.1 → workers_py-1.7.0}/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 <!-- version list -->
 
+## v1.7.0 (2025-10-31)
+
+### Features
+
+- Better errors when unsupported packages are requested
+  ([`e5000ed`](https://github.com/cloudflare/workers-py/commit/e5000eded90fb89c8f1a46dfb107f6d246f53e89))
+
+
+## v1.6.2 (2025-10-22)
+
+### Bug Fixes
+
+- Add workers-runtime-sdk as a dependency, update type test
+  ([#41](https://github.com/cloudflare/workers-py/pull/41),
+  [`f381505`](https://github.com/cloudflare/workers-py/commit/f381505e4c9b40ddb602928d964aa3fe38936e5c))
+
+
 ## v1.6.1 (2025-10-15)
 
 ### Bug Fixes

{workers_py-1.6.1 → workers_py-1.7.0}/PKG-INFO

@@ -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.6.1 → workers_py-1.7.0}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "hatchling.build"
 
 [project]
 name = "workers-py"
-version = "1.6.1"
+version = "1.7.0"
 description = "A set of libraries and tools for Python Workers"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.12"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: MIT License",
@@ -19,6 +19,7 @@ dependencies = [
     "pyodide-cli",
     "pyjson5>=1.6.0",
     "pyodide-py",
+    "workers-runtime-sdk>=0.1.0",
 ]
 
 [dependency-groups]
@@ -42,20 +43,33 @@ pywrangler = "pywrangler.cli:app"
 "Bug Tracker" = "https://github.com/cloudflare/workers-py/issues"
 
 [tool.ruff]
-target-version = "py38"
-src = ["src", "tests"]
-lint.select = ["E", "F"]
-lint.ignore = ["E501"] # Line too long
+target-version = "py312"
+lint.select = [
+  "B0",     # bugbear (all B0* checks enabled by default)
+  "B904",   # bugbear (Within an except clause, raise exceptions with raise ... from err)
+  "B905",   # bugbear (zip() without an explicit strict= parameter set.)
+  "C4",     # flake8-comprehensions
+  "C9",     # mccabe complexity
+  "E",      # pycodestyles
+  "F",      # pyflakes
+  "I",      # isort
+  "PERF",   # Perflint
+  "PGH",    # pygrep-hooks
+  "PL",     # Pylint
+  "UP",     # pyupgrade
+  "W",      # pycodestyles
+]
+lint.ignore = ["E402", "E501", "E731", "E741", "PLW2901", "UP031"]
+lint.flake8-comprehensions.allow-dict-calls-with-keyword-arguments = true
 
 [tool.mypy]
-python_version = "3.8"
-warn_return_any = true
-warn_unused_configs = true
-disallow_untyped_defs = true
-disallow_incomplete_defs = true
-disallow_untyped_decorators = false
-check_untyped_defs = true
-disallow_any_generics = false
+packages = ["pywrangler"]
+python_version = "3.12"
+
+show_error_codes = true
+
+strict = true
+warn_unreachable = true
 no_implicit_optional = true
 
 [[tool.mypy.overrides]]

{workers_py-1.6.1 → workers_py-1.7.0}/src/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:

workers_py-1.7.0/src/pywrangler/sync.py

@@ -0,0 +1,336 @@
+import logging
+import os
+import shutil
+import tempfile
+from collections.abc import Iterator
+from contextlib import contextmanager
+from pathlib import Path
+
+import click
+
+from .utils import (
+    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,
+)
+
+logger = logging.getLogger(__name__)
+
+
+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 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) as f:
+            requirements = f.read().splitlines()
+            logger.warning(
+                "Specifying Python Packages in requirements.txt is no longer supported, please use pyproject.toml instead.\n"
+                + "Put the following in your pyproject.toml to vendor the packages currently in your requirements.txt:"
+            )
+            pyproject_text = "dependencies = [\n"
+            pyproject_text += ",\n".join([f'  "{x}"' for x in requirements])
+            pyproject_text += "\n]"
+            logger.warning(pyproject_text)
+
+        logger.error(
+            f"{old_requirements_txt} exists. Delete the file to continue. Exiting."
+        )
+        raise click.exceptions.Exit(code=1)
+
+
+def _get_venv_python_version() -> str | None:
+    """
+    Retrieves the Python version from the virtual environment.
+
+    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"
+        if os.name == "nt"
+        else venv_workers_path / "bin" / "python"
+    )
+    if not venv_python.is_file():
+        return None
+
+    result = run_command(
+        [str(venv_python), "--version"], check=False, capture_output=True
+    )
+    if result.returncode != 0:
+        return None
+
+    return result.stdout.strip()
+
+
+def create_workers_venv() -> None:
+    """
+    Creates a virtual environment at `venv_workers_path` if it doesn't exist.
+    """
+    wanted_python_version = get_python_version()
+    logger.debug(f"Using python version from wrangler config: {wanted_python_version}")
+
+    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."
+                )
+                return
+
+            logger.warning(
+                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."
+            )
+
+        shutil.rmtree(venv_workers_path)
+
+    logger.debug(f"Creating virtual environment at {venv_workers_path}...")
+    run_command(
+        [
+            "uv",
+            "venv",
+            str(venv_workers_path),
+            "--python",
+            f"python{wanted_python_version}",
+        ]
+    )
+
+
+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."
+        )
+        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()
+    run_command(["uv", "python", "install", interp_name])
+    run_command(["uv", "venv", pyodide_venv_path, "--python", interp_name])
+
+
+def parse_requirements() -> list[str]:
+    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]) -> 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))
+        temp_file.flush()
+        yield temp_file.name
+
+
+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:
+        logger.warning(
+            f"Requirements list is empty. No dependencies to install in {vendor_path}."
+        )
+        return
+
+    # Install packages into vendor directory
+    vendor_path.mkdir(parents=True, exist_ok=True)
+    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:
+        result = run_command(
+            [
+                "uv",
+                "pip",
+                "install",
+                "--no-build",
+                "-r",
+                requirements_file,
+                "--extra-index-url",
+                get_pyodide_index(),
+                "--index-strategy",
+                "unsafe-best-match",
+            ],
+            capture_output=True,
+            check=False,
+            env=os.environ | {"VIRTUAL_ENV": get_pyodide_venv_path()},
+        )
+        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(
+            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()
+    get_vendor_token_path().touch()
+
+    logger.info(
+        f"Packages installed in [bold]{relative_vendor_path}[/bold].",
+        extra={"markup": True},
+    )
+
+
+def _install_requirements_to_venv(requirements: list[str]) -> None:
+    # Create a requirements file for .venv-workers that includes pyodide-py
+    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")
+
+    logger.info(
+        f"Installing packages into [bold]{relative_venv_workers_path}[/bold]...",
+        extra={"markup": True},
+    )
+    with temp_requirements_file(requirements) as requirements_file:
+        result = run_command(
+            [
+                "uv",
+                "pip",
+                "install",
+                "-r",
+                requirements_file,
+            ],
+            check=False,
+            env=os.environ | {"VIRTUAL_ENV": venv_workers_path},
+            capture_output=True,
+        )
+        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]) -> 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:
+    if not token.exists():
+        return True
+    return time > token.stat().st_mtime
+
+
+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
+    """
+    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(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)

{workers_py-1.6.1 → workers_py-1.7.0}/src/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]