Fix uses of env and ctx in Python examples (#24790)

Since #24392, most of the Python examples use env and ctx incorrectly. This fixes it.

I also replaced all tabs with spaces in signing-requests.mdx.

Author: hoodmane

src/content/changelog/workers/2025-05-14-python-worker-durable-object.mdx

@@ -32,7 +32,7 @@ class MyDurableObject(DurableObject):
         return Response(result.greeting)
 
 class Default(WorkerEntrypoint):
-    async def fetch(self, request, env, ctx):
+    async def fetch(self, request):
         url = urlparse(request.url)
         id = env.MY_DURABLE_OBJECT.idFromName(url.path)
         stub = env.MY_DURABLE_OBJECT.get(id)

src/content/changelog/workers/2025-08-14-new-python-handlers.mdx

@@ -16,7 +16,7 @@ Here's an example of how to now define a Worker with a fetch handler:
 from workers import Response, WorkerEntrypoint
 
 class Default(WorkerEntrypoint):
-    async def fetch(self, request, env, ctx):
+    async def fetch(self, request):
         return Response("Hello World!")
 ```
 

src/content/docs/d1/examples/query-d1-from-python-workers.mdx

@@ -84,11 +84,11 @@ To create a Python Worker, create an empty file at `src/entry.py`, matching the
 from workers import Response, WorkerEntrypoint
 
 class Default(WorkerEntrypoint):
-    async def fetch(self, request, env):
+    async def fetch(self, request):
         # Do anything else you'd like on request here!
 
         # Query D1 - we'll list all tables in our database in this example
-        results = await env.DB.prepare("PRAGMA table_list").run()
+        results = await self.env.DB.prepare("PRAGMA table_list").run()
         # Return a JSON response
         return Response.json(results)
 

src/content/docs/durable-objects/get-started.mdx

@@ -225,9 +225,9 @@ from workers import handler, Response, WorkerEntrypoint
 from urllib.parse import urlparse
 
 class Default(WorkerEntrypoint):
-    async def fetch(request, env, ctx):
+    async def fetch(request):
         url = urlparse(request.url)
-        stub = env.MY_DURABLE_OBJECT.getByName(url.path)
+        stub = self.env.MY_DURABLE_OBJECT.getByName(url.path)
         greeting = await stub.say_hello()
         return Response(greeting)
 ```
@@ -360,9 +360,9 @@ class MyDurableObject(DurableObject):
         return result.greeting
 
 class Default(WorkerEntrypoint):
-    async def fetch(self, request, env, ctx):
+    async def fetch(self, request):
         url = urlparse(request.url)
-        stub = env.MY_DURABLE_OBJECT.getByName(url.path)
+        stub = self.env.MY_DURABLE_OBJECT.getByName(url.path)
         greeting = await stub.say_hello()
         return Response(greeting)
 ```

src/content/docs/workers/examples/cache-api.mdx

@@ -111,7 +111,7 @@ from pyodide.ffi import create_proxy
 from js import Response, Request, URL, caches, fetch
 
 class Default(WorkerEntrypoint):
-    async def fetch(self, request, _env, ctx):
+    async def fetch(self, request):
         cache_url = request.url
 
         # Construct the cache key from the cache URL
@@ -133,7 +133,7 @@ class Default(WorkerEntrypoint):
             # will limit the response to be in cache for 10 seconds s-maxage
             # Any changes made to the response here will be reflected in the cached value
             response.headers.append("Cache-Control", "s-maxage=10")
-            ctx.waitUntil(create_proxy(cache.put(cache_key, response.clone())))
+            self.ctx.waitUntil(create_proxy(cache.put(cache_key, response.clone())))
         else:
             print(f"Cache hit for: {request.url}.")
         return response

src/content/docs/workers/examples/debugging-logs.mdx

@@ -124,7 +124,7 @@ async def post_log(data):
 	await fetch(log_url, method="POST", body=data)
 
 class Default(WorkerEntrypoint):
-    async def fetch(self, request, _env, ctx):
+    async def fetch(self, request):
         # Service configured to receive logs
         response = await fetch(request)
 
@@ -136,7 +136,7 @@ class Default(WorkerEntrypoint):
         except Exception as e:
             # Without ctx.waitUntil(), your fetch() to Cloudflare's
             # logging service may or may not complete
-            ctx.waitUntil(create_proxy(post_log(str(e))))
+            self.ctx.waitUntil(create_proxy(post_log(str(e))))
             # Copy the response and add to header
             response = Response.new(stack, response)
             response.headers["X-Debug-err"] = str(e)

src/content/docs/workers/examples/protect-against-timing-attacks.mdx

@@ -77,9 +77,9 @@ from workers import WorkerEntrypoint, Response
 from js import TextEncoder, crypto
 
 class Default(WorkerEntrypoint):
-    async def fetch(self, request, env):
+    async def fetch(self, request):
         auth_token = request.headers["Authorization"] or ""
-        secret = env.MY_SECRET_VALUE
+        secret = self.env.MY_SECRET_VALUE
 
         if secret is None:
             return Response("Missing secret binding", status=500)

src/content/docs/workers/examples/signing-requests.mdx

@@ -387,75 +387,75 @@ encoder = TextEncoder.new()
 EXPIRY = 60
 
 class Default(WorkerEntrypoint):
-    async def fetch(self, request, env):
-		# Get the secret key
-		secret_key_data = encoder.encode(env.SECRET_DATA if hasattr(env, "SECRET_DATA") else "my secret symmetric key")
+    async def fetch(self, request):
+        # Get the secret key
+        secret_key_data = encoder.encode(getattr(self.env, "SECRET_DATA", None) or "my secret symmetric key")
 
-		# Import the secret as a CryptoKey for both 'sign' and 'verify' operations
-		key = await crypto.subtle.importKey(
-			"raw",
-			secret_key_data,
-			to_js({"name": "HMAC", "hash": "SHA-256"}),
-			False,
-			["sign", "verify"]
-		)
+        # Import the secret as a CryptoKey for both 'sign' and 'verify' operations
+        key = await crypto.subtle.importKey(
+            "raw",
+            secret_key_data,
+            to_js({"name": "HMAC", "hash": "SHA-256"}),
+            False,
+            ["sign", "verify"]
+        )
 
-		url = URL.new(request.url)
+        url = URL.new(request.url)
 
-		if url.pathname.startswith("/generate/"):
-			url.pathname = url.pathname.replace("/generate/", "/", 1)
+        if url.pathname.startswith("/generate/"):
+            url.pathname = url.pathname.replace("/generate/", "/", 1)
 
-			timestamp = int(Date.now() / 1000)
+            timestamp = int(Date.now() / 1000)
 
-			# Data to authenticate
-			data_to_authenticate = f"{url.pathname}{timestamp}"
+            # Data to authenticate
+            data_to_authenticate = f"{url.pathname}{timestamp}"
 
-			# Sign the data
-			mac = await crypto.subtle.sign(
-				"HMAC",
-				key,
-				encoder.encode(data_to_authenticate)
-			)
+            # Sign the data
+            mac = await crypto.subtle.sign(
+                "HMAC",
+                key,
+                encoder.encode(data_to_authenticate)
+            )
 
-			# Convert to base64
-			base64_mac = Buffer.from(mac).toString("base64")
+            # Convert to base64
+            base64_mac = Buffer.from(mac).toString("base64")
 
-			# Set the verification parameter
-			url.searchParams.set("verify", f"{timestamp}-{base64_mac}")
+            # Set the verification parameter
+            url.searchParams.set("verify", f"{timestamp}-{base64_mac}")
 
-			return Response.new(f"{url.pathname}{url.search}")
-		else:
-			# Verify the request
-			if not "verify" in url.searchParams:
-				return Response.new("Missing query parameter", status=403)
+            return Response.new(f"{url.pathname}{url.search}")
+        else:
+            # Verify the request
+            if not "verify" in url.searchParams:
+                return Response.new("Missing query parameter", status=403)
 
-			verify_param = url.searchParams.get("verify")
-			timestamp, hmac = verify_param.split("-")
+            verify_param = url.searchParams.get("verify")
+            timestamp, hmac = verify_param.split("-")
 
-			asserted_timestamp = int(timestamp)
+            asserted_timestamp = int(timestamp)
 
-			data_to_authenticate = f"{url.pathname}{asserted_timestamp}"
+            data_to_authenticate = f"{url.pathname}{asserted_timestamp}"
 
-			received_mac = Buffer.from(hmac, "base64")
+            received_mac = Buffer.from(hmac, "base64")
 
-			# Verify the signature
-			verified = await crypto.subtle.verify(
-				"HMAC",
-				key,
-				received_mac,
-				encoder.encode(data_to_authenticate)
-			)
+            # Verify the signature
+            verified = await crypto.subtle.verify(
+                "HMAC",
+                key,
+                received_mac,
+                encoder.encode(data_to_authenticate)
+            )
 
-			if not verified:
-				return Response.new("Invalid MAC", status=403)
+            if not verified:
+                return Response.new("Invalid MAC", status=403)
 
-			# Check expiration
-			if Date.now() / 1000 > asserted_timestamp + EXPIRY:
-				expiry_date = Date.new((asserted_timestamp + EXPIRY) * 1000)
-				return Response.new(f"URL expired at {expiry_date}", status=403)
+            # Check expiration
+            if Date.now() / 1000 > asserted_timestamp + EXPIRY:
+                expiry_date = Date.new((asserted_timestamp + EXPIRY) * 1000)
+                return Response.new(f"URL expired at {expiry_date}", status=403)
 
-		# Proxy to example.com if verification passes
-		return fetch(URL.new(f"https://example.com{url.pathname}"), request)
+        # Proxy to example.com if verification passes
+        return fetch(URL.new(f"https://example.com{url.pathname}"), request)
 ```
 
 </TabItem> </Tabs>

src/content/docs/workers/examples/turnstile-html-rewriter.mdx

@@ -217,9 +217,9 @@ from pyodide.ffi import create_proxy
 from js import HTMLRewriter, fetch
 
 class Default(WorkerEntrypoint):
-    async def fetch(self, request, env):
-        site_key = env.SITE_KEY
-        attr_name = env.TURNSTILE_ATTR_NAME
+    async def fetch(self, request):
+        site_key = self.env.SITE_KEY
+        attr_name = self.env.TURNSTILE_ATTR_NAME
         res = await fetch(request)
 
         class Append:
@@ -264,7 +264,7 @@ async function handlePost(request, env) {
     let formData = new FormData();
 
     // `secret_key` here is the Turnstile Secret key, which should be set using Wrangler secrets
-    formData.append('secret', env.SECRET_KEY);
+    formData.append('secret', self.env.SECRET_KEY);
     formData.append('response', token);
     formData.append('remoteip', ip); //This is optional.
 

src/content/docs/workers/languages/python/examples.mdx

@@ -18,7 +18,7 @@ from workers import WorkerEntrypoint, Response
 from urllib.parse import urlparse, parse_qs
 
 class Default(WorkerEntrypoint):
-    async def fetch(self, request, env):
+    async def fetch(self, request):
         # Parse the incoming request URL
         url = urlparse(request.url)
         # Parse the query parameters into a Python dictionary
@@ -89,15 +89,15 @@ def to_js(obj):
    return _to_js(obj, dict_converter=Object.fromEntries)
 
 class Default(WorkerEntrypoint):
-    async def fetch(self, request, env):
-        # Bindings are available on the 'env' parameter
+    async def fetch(self, request):
+        # Bindings are available on the 'env' attribute
         # https://developers.cloudflare.com/queues/
 
         # The default contentType is "json"
         # We can also pass plain text strings
-        await env.QUEUE.send("hello", contentType="text")
+        await self.env.QUEUE.send("hello", contentType="text")
         # Send a JSON payload
-        await env.QUEUE.send(to_js({"hello": "world"}))
+        await self.env.QUEUE.send(to_js({"hello": "world"}))
 
         # Return a response
         return Response.json({"write": "success"})
@@ -109,8 +109,8 @@ class Default(WorkerEntrypoint):
 from workers import WorkerEntrypoint, Response
 
 class Default(WorkerEntrypoint):
-    async def fetch(self, request, env):
-        results = await env.DB.prepare("PRAGMA table_list").run()
+    async def fetch(self, request):
+        results = await self.env.DB.prepare("PRAGMA table_list").run()
         # Return a JSON response
         return Response.json(results)
 ```