workers-py 1.6.2__tar.gz → 1.7.1__tar.gz

{workers_py-1.6.2 → workers_py-1.7.1}/.github/workflows/tests.yml

@@ -11,7 +11,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest]
-        python-version: ['3.12']
+        python-version: ['3.12', '3.13']
     runs-on: ${{ matrix.os }}
 
     steps:

{workers_py-1.6.2 → workers_py-1.7.1}/.gitignore

@@ -62,3 +62,5 @@ docs/_build/
 # OS specific
 .DS_Store
 Thumbs.db
+
+tests/test_workspace

{workers_py-1.6.2 → workers_py-1.7.1}/.pre-commit-config.yaml

@@ -1,4 +1,3 @@
-exclude: (^.*patches|.*\.cgi$|^packages/micropip/src/micropip/externals|^benchmark/benchmarks$)
 default_language_version:
   python: "3.13"
 repos:

{workers_py-1.6.2 → workers_py-1.7.1}/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 <!-- version list -->
 
+## v1.7.1 (2026-02-03)
+
+### Bug Fixes
+
+- Address comment ([#62](https://github.com/cloudflare/workers-py/pull/62),
+  [`53ce7be`](https://github.com/cloudflare/workers-py/commit/53ce7be9385f2aa07d8c43d5d3296d6328aafca7))
+
+- Better windows platform support ([#62](https://github.com/cloudflare/workers-py/pull/62),
+  [`53ce7be`](https://github.com/cloudflare/workers-py/commit/53ce7be9385f2aa07d8c43d5d3296d6328aafca7))
+
+- Ensure to cleanup the test directory ([#62](https://github.com/cloudflare/workers-py/pull/62),
+  [`53ce7be`](https://github.com/cloudflare/workers-py/commit/53ce7be9385f2aa07d8c43d5d3296d6328aafca7))
+
+- Fix incorrect abspath ([#62](https://github.com/cloudflare/workers-py/pull/62),
+  [`53ce7be`](https://github.com/cloudflare/workers-py/commit/53ce7be9385f2aa07d8c43d5d3296d6328aafca7))
+
+
+## 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

{workers_py-1.6.2 → workers_py-1.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workers-py
-Version: 1.6.2
+Version: 1.7.1
 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

{workers_py-1.6.2 → workers_py-1.7.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "workers-py"
-version = "1.6.2"
+version = "1.7.1"
 description = "A set of libraries and tools for Python Workers"
 readme = "README.md"
 requires-python = ">=3.12"

{workers_py-1.6.2 → workers_py-1.7.1}/src/pywrangler/cli.py

@@ -2,6 +2,7 @@ import logging
 import subprocess
 import sys
 import textwrap
+from pathlib import Path
 from typing import Never
 
 import click
@@ -11,6 +12,8 @@ from .utils import (
     WRANGLER_COMMAND,
     WRANGLER_CREATE_COMMAND,
     check_wrangler_version,
+    log_startup_info,
+    run_command,
     setup_logging,
     write_success,
 )
@@ -56,6 +59,8 @@ class ProxyToWranglerGroup(click.Group):
         command = super().get_command(ctx, cmd_name)
 
         if command is None:
+            log_startup_info()
+
             try:
                 cmd_index = sys.argv.index(cmd_name)
                 remaining_args = sys.argv[cmd_index + 1 :]
@@ -106,6 +111,8 @@ def app(debug: bool = False) -> None:
     if debug:
         logger.setLevel(logging.DEBUG)
 
+    log_startup_info()
+
 
 @app.command("types")
 @click.option(
@@ -135,6 +142,7 @@ def sync_command(force: bool = False) -> None:
 
     Also creates a virtual env for Workers that you can use for testing.
     """
+
     sync(force, directly_requested=True)
     write_success("Sync process completed successfully.")
 
@@ -143,7 +151,7 @@ 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:
-        process = subprocess.run(command_to_run, check=False, cwd=".")
+        process = run_command(command_to_run, check=False, cwd=Path("."))
         click.get_current_context().exit(process.returncode)
     except FileNotFoundError as e:
         logger.error(
@@ -156,7 +164,7 @@ 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:
-        process = subprocess.run(command_to_run, check=False, cwd=".")
+        process = run_command(command_to_run, check=False, cwd=Path("."))
         click.get_current_context().exit(process.returncode)
     except FileNotFoundError as e:
         logger.error(

{workers_py-1.6.2 → workers_py-1.7.1}/src/pywrangler/sync.py

@@ -137,7 +137,7 @@ def create_pyodide_venv() -> None:
     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", str(pyodide_venv_path), "--python", interp_name])
 
 
 def parse_requirements() -> list[str]:
@@ -147,6 +147,9 @@ def parse_requirements() -> list[str]:
     dependencies = pyproject_data.get("project", {}).get("dependencies", [])
 
     logger.info(f"Found {len(dependencies)} dependencies.")
+    if dependencies:
+        for dep in dependencies:
+            logger.debug(f"  - {dep}")
     return dependencies
 
 
@@ -177,7 +180,7 @@ def _install_requirements_to_vendor(requirements: list[str]) -> None:
         extra={"markup": True},
     )
     with temp_requirements_file(requirements) as requirements_file:
-        run_command(
+        result = run_command(
             [
                 "uv",
                 "pip",
@@ -190,13 +193,41 @@ def _install_requirements_to_vendor(requirements: list[str]) -> None:
                 "--index-strategy",
                 "unsafe-best-match",
             ],
-            env=os.environ | {"VIRTUAL_ENV": get_pyodide_venv_path()},
+            capture_output=True,
+            check=False,
+            env=os.environ | {"VIRTUAL_ENV": str(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)
+
+        _log_installed_packages(get_pyodide_venv_path())
+
         pyv = get_python_version()
         shutil.rmtree(vendor_path)
-        shutil.copytree(
-            get_pyodide_venv_path() / f"lib/python{pyv}/site-packages", vendor_path
+
+        site_packages_path = (
+            f"lib/python{pyv}/site-packages" if os.name != "nt" else "Lib/site-packages"
         )
+        shutil.copytree(get_pyodide_venv_path() / site_packages_path, vendor_path)
 
     # Create a pyvenv.cfg file in python_modules to mark it as a virtual environment
     (vendor_path / "pyvenv.cfg").touch()
@@ -208,6 +239,20 @@ def _install_requirements_to_vendor(requirements: list[str]) -> None:
     )
 
 
+def _log_installed_packages(venv_path: Path) -> None:
+    result = run_command(
+        ["uv", "pip", "list", "--format=freeze"],
+        env=os.environ | {"VIRTUAL_ENV": venv_path},
+        capture_output=True,
+        check=False,
+    )
+    if result.returncode == 0 and result.stdout.strip():
+        logger.debug("Installed packages:")
+        for line in result.stdout.strip().split("\n"):
+            if line.strip():
+                logger.debug(f"  {line.strip()}")
+
+
 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()
@@ -221,7 +266,7 @@ def _install_requirements_to_venv(requirements: list[str]) -> None:
         extra={"markup": True},
     )
     with temp_requirements_file(requirements) as requirements_file:
-        run_command(
+        result = run_command(
             [
                 "uv",
                 "pip",
@@ -229,8 +274,16 @@ def _install_requirements_to_venv(requirements: list[str]) -> None:
                 "-r",
                 requirements_file,
             ],
-            env=os.environ | {"VIRTUAL_ENV": venv_workers_path},
+            check=False,
+            env=os.environ | {"VIRTUAL_ENV": str(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(
@@ -240,8 +293,14 @@ def _install_requirements_to_venv(requirements: list[str]) -> None:
 
 
 def install_requirements(requirements: list[str]) -> None:
-    _install_requirements_to_vendor(requirements)
+    # 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:
@@ -275,12 +334,15 @@ def sync(force: bool = False, directly_requested: bool = False) -> None:
     # Check if sync is needed based on file timestamps
     sync_needed = force or is_sync_needed()
     if not sync_needed:
+        logger.debug("Sync not needed - no changes detected")
         if directly_requested:
             logger.warning(
                 "pyproject.toml hasn't changed since last sync, use --force to ignore timestamp check"
             )
         return
 
+    logger.debug("Sync needed - proceeding with installation")
+
     # Check to make sure a wrangler config file exists.
     check_wrangler_config()
 

{workers_py-1.6.2 → workers_py-1.7.1}/src/pywrangler/types.py

@@ -39,8 +39,10 @@ def wrangler_types(outdir_arg: str | None, config: str | None, /) -> None:
     stubs_dir.mkdir(parents=True, exist_ok=True)
     with TemporaryDirectory() as tmp_str:
         tmp = Path(tmp_str)
-        run_command(WRANGLER_COMMAND + args + [tmp / "worker-configuration.d.ts"])
+        run_command(WRANGLER_COMMAND + args + [str(tmp / "worker-configuration.d.ts")])
         (tmp / "tsconfig.json").write_text(TSCONFIG)
         (tmp / "package.json").write_text(PACKAGE_JSON)
-        run_command(["npm", "-C", tmp, "install"])
-        run_command(["npx", "@pyodide/ts-to-python", tmp, stubs_dir / "__init__.pyi"])
+        run_command(["npm", "-C", str(tmp), "install"])
+        run_command(
+            ["npx", "@pyodide/ts-to-python", str(tmp), str(stubs_dir / "__init__.pyi")]
+        )

{workers_py-1.6.2 → workers_py-1.7.1}/src/pywrangler/utils.py

@@ -1,7 +1,12 @@
 import logging
+import os
+import platform
 import re
+import shutil
 import subprocess
+import sys
 import tomllib
+from collections.abc import Mapping
 from datetime import datetime
 from functools import cache
 from pathlib import Path
@@ -20,12 +25,47 @@ WRANGLER_CREATE_COMMAND = ["npx", "--yes", "create-cloudflare"]
 
 logger = logging.getLogger(__name__)
 
-SUCCESS_LEVEL = 100
-RUNNING_LEVEL = 15
-OUTPUT_LEVEL = 16
+SUCCESS_LEVEL = logging.CRITICAL + 50
+RUNNING_LEVEL = logging.DEBUG + 5
+OUTPUT_LEVEL = logging.DEBUG + 6
 
+# Valid log levels for PYWRANGLER_LOG environment variable
+_LOG_LEVEL_MAP = {
+    "debug": logging.DEBUG,
+    "info": logging.INFO,
+    "warning": logging.WARNING,
+    "warn": logging.WARNING,  # alias
+    "error": logging.ERROR,
+}
+
+
+def setup_logging() -> int:
+    """
+    Configure logging with Rich handler.
+
+    Reads PYWRANGLER_LOG environment variable to set log level.
+    Valid values: debug, info, warning, warn, error (case-insensitive).
+    Defaults to INFO if not set or invalid.
+
+    Returns:
+        The configured logging level (e.g., logging.DEBUG, logging.INFO).
+    """
+    # Determine log level from environment variable
+    env_level = os.environ.get("PYWRANGLER_LOG", "").lower().strip()
+    if env_level and env_level not in _LOG_LEVEL_MAP:
+        # Print warning to stderr for invalid value (before logging is configured)
+        print(
+            f"Warning: Invalid PYWRANGLER_LOG value '{env_level}'. "
+            f"Valid values: {', '.join(sorted(set(_LOG_LEVEL_MAP.keys())))}. "
+            "Defaulting to 'info'.",
+            file=sys.stderr,
+        )
+        log_level = logging.INFO
+    elif env_level:
+        log_level = _LOG_LEVEL_MAP[env_level]
+    else:
+        log_level = logging.INFO
 
-def setup_logging() -> None:
     console = Console(
         theme=Theme(
             {
@@ -39,7 +79,7 @@ def setup_logging() -> None:
 
     # Configure Rich logger
     logging.basicConfig(
-        level=logging.INFO,
+        level=log_level,
         format="%(message)s",
         force=True,  # Ensure this configuration is applied
         handlers=[
@@ -52,15 +92,37 @@ def setup_logging() -> None:
     logging.addLevelName(RUNNING_LEVEL, "RUNNING")
     logging.addLevelName(OUTPUT_LEVEL, "OUTPUT")
 
+    return log_level
+
+
+def _get_pywrangler_version() -> str:
+    """Get the version of pywrangler."""
+    try:
+        from importlib.metadata import version
+
+        return version("workers-py")
+    except Exception:
+        return "unknown"
+
+
+def log_startup_info() -> None:
+    """
+    Log startup information for debugging.
+    """
+    logger.debug(f"pywrangler version: {_get_pywrangler_version()}")
+    logger.debug(f"Python: {platform.python_version()}")
+    logger.debug(f"Platform: {sys.platform}")
+    logger.debug(f"Working directory: {Path.cwd()}")
+
 
 def write_success(msg: str) -> None:
     logging.log(SUCCESS_LEVEL, msg)
 
 
 def run_command(
-    command: list[str | Path],
+    command: list[str],
     cwd: Path | None = None,
-    env: dict[str, str | Path] | None = None,
+    env: Mapping[str, str | Path] | None = None,
     check: bool = True,
     capture_output: bool = False,
 ) -> subprocess.CompletedProcess[str]:
@@ -78,21 +140,36 @@ def run_command(
         A subprocess.CompletedProcess instance.
     """
     logger.log(RUNNING_LEVEL, f"{' '.join(str(arg) for arg in command)}")
+
+    # Some tools like `npm` may be a batch file on Windows (npm.cmd), and calling them only by
+    # name may fails in subprocess.run. Use shutil.which to find the real name.
+    abspath = shutil.which(command[0])
+    if not abspath:
+        logger.error(f"Command not found: {command[0]}. Is it installed and in PATH?")
+        raise click.exceptions.Exit(code=1)
+
+    realname = str(Path(command[0]).with_name(Path(abspath).name))
+    command = [realname] + command[1:]
     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,
-        )
+            encoding="utf-8",
+            **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) from None
     except FileNotFoundError:

{workers_py-1.6.2 → workers_py-1.7.1}/tests/test_cli.py

@@ -51,7 +51,11 @@ def test_dir(monkeypatch):
     monkeypatch.setattr(
         pywrangler_utils, "find_pyproject_toml", lambda: test_dir / "pyproject.toml"
     )
-    yield test_dir.absolute()
+
+    try:
+        yield test_dir.absolute()
+    finally:
+        shutil.rmtree(test_dir, ignore_errors=True)
 
 
 def create_test_pyproject(test_dir: Path, dependencies=None):
@@ -410,7 +414,12 @@ def test_proxy_to_wrangler_handles_subprocess_error(mock_subprocess_run):
 
     # Verify the error was attempted to be called
     mock_subprocess_run.assert_called_once_with(
-        ["npx", "--yes", "wrangler", "unknown_command"], check=False, cwd="."
+        ["npx", "--yes", "wrangler", "unknown_command"],
+        check=False,
+        cwd=Path("."),
+        env=None,
+        text=True,
+        encoding="utf-8",
     )
 
 
@@ -542,3 +551,114 @@ def test_check_wrangler_version_insufficient(mock_run_command):
 
     with pytest.raises(click.exceptions.Exit):
         check_wrangler_version()
+
+
+# Tests for PYWRANGLER_LOG environment variable
+
+
+def test_env_var_debug_level(test_dir, monkeypatch, caplog):
+    monkeypatch.setenv("PYWRANGLER_LOG", "debug")
+    create_test_pyproject(test_dir)
+    create_test_wrangler_jsonc(test_dir)
+
+    # Need to reimport to pick up env var change
+    import importlib
+
+    import pywrangler.utils
+
+    importlib.reload(pywrangler.utils)
+
+    from pywrangler.utils import setup_logging
+
+    level = setup_logging()
+    assert level == logging.DEBUG
+
+
+def test_env_var_error_level(test_dir, monkeypatch):
+    """Test that PYWRANGLER_LOG=error sets ERROR level."""
+    monkeypatch.setenv("PYWRANGLER_LOG", "error")
+
+    import importlib
+
+    import pywrangler.utils
+
+    importlib.reload(pywrangler.utils)
+
+    from pywrangler.utils import setup_logging
+
+    level = setup_logging()
+    assert level == logging.ERROR
+
+
+def test_env_var_case_insensitive(test_dir, monkeypatch):
+    """Test that PYWRANGLER_LOG is case-insensitive."""
+    monkeypatch.setenv("PYWRANGLER_LOG", "DEBUG")
+
+    import importlib
+
+    import pywrangler.utils
+
+    importlib.reload(pywrangler.utils)
+
+    from pywrangler.utils import setup_logging
+
+    level = setup_logging()
+    assert level == logging.DEBUG
+
+
+def test_debug_flag_overrides_env(test_dir, monkeypatch, caplog):
+    """Test that --debug flag overrides PYWRANGLER_LOG=error."""
+    monkeypatch.setenv("PYWRANGLER_LOG", "error")
+    create_test_pyproject(test_dir)
+    create_test_wrangler_jsonc(test_dir)
+
+    runner = CliRunner()
+    runner.invoke(app, ["--debug", "sync"])
+
+    debug_logs = [
+        record for record in caplog.records if record.levelno == logging.DEBUG
+    ]
+    assert len(debug_logs) > 0, "--debug flag should override PYWRANGLER_LOG=error"
+
+
+def test_env_var_invalid(test_dir, monkeypatch, capsys):
+    """Test that invalid PYWRANGLER_LOG value produces warning."""
+    monkeypatch.setenv("PYWRANGLER_LOG", "invalid_value")
+
+    import importlib
+
+    import pywrangler.utils
+
+    importlib.reload(pywrangler.utils)
+
+    from pywrangler.utils import setup_logging
+
+    level = setup_logging()
+
+    captured = capsys.readouterr()
+    assert "Warning" in captured.err
+    assert "invalid_value" in captured.err
+    assert level == logging.INFO
+
+
+def test_startup_banner(test_dir, monkeypatch):
+    """Test that debug output contains version, platform, and working directory."""
+    monkeypatch.setenv("PYWRANGLER_LOG", "debug")
+    create_test_pyproject(test_dir)
+    create_test_wrangler_jsonc(test_dir)
+
+    import importlib
+
+    import pywrangler.utils
+
+    importlib.reload(pywrangler.utils)
+
+    from pywrangler.utils import _get_pywrangler_version, log_startup_info
+
+    # Verify the functions exist and return expected content
+    version = _get_pywrangler_version()
+    assert version is not None
+
+    # Verify log_startup_info can be called without error
+    # The actual logging is tested via integration in test_debug_flag
+    log_startup_info()

{workers_py-1.6.2 → workers_py-1.7.1}/tests/test_types.py

@@ -1,6 +1,9 @@
+import sys
 from contextlib import chdir
 from subprocess import run
 
+import pytest
+
 # Import the full module so we can patch constants
 from pywrangler.types import wrangler_types
 
@@ -42,7 +45,9 @@ class Default(WorkerEntrypoint):
 """
 
 
+@pytest.mark.skipif(sys.version_info < (3, 13), reason="We create Python 3.13+ syntax")
 def test_types(tmp_path):
+    """Test that types are correctly revealed in a worker."""
     config_path = tmp_path / "wrangler.toml"
     pyproject_path = tmp_path / "pyproject.toml"
     worker_dir = tmp_path / "src/worker"

{workers_py-1.6.2 → workers_py-1.7.1}/uv.lock

@@ -500,7 +500,7 @@ wheels = [
 
 [[package]]
 name = "workers-py"
-version = "1.6.2"
+version = "1.7.1"
 source = { editable = "." }
 dependencies = [
     { name = "click" },