Python on NoRaincheck

Notes on Resizing Images

Sat, 18 Jul 2026 00:00:00 +0000

Notes on Resizing Images

July 2026

Given the influx of AI and readily available tools for things like super resolution (e.g. RealESRGAN), better ways to enhance images when resizing downwards becomes important as well.

The broad idea we should use looks like:

 1orig_w, orig_h = img.size
 2new_h = round(TARGET_WIDTH * orig_h / orig_w)
 3
 4# Gaussian blur pre-filter for anti-aliasing
 5blurred = img.filter(ImageFilter.GaussianBlur(radius=0.5))
 6
 7# One-step Lanczos downscale
 8resized = blurred.resize((TARGET_WIDTH, new_h), Image.LANCZOS)
 9
10output_path = OUTPUT_DIR / f"page_{page_num:03d}.png"
11resized.save(output_path, "PNG", optimize=True)

Where setting something like radius being related to the size of the image scaled. For example, if the resulting image is half the size log the original image, a radius=0.5 is probably appropriate. Whereas if it is 1/5 of the size maybe radius of 1 to 1.5 is better. If you’re after an equation, radius=math.log(scale) is pretty close to the target.

Beating FastAPI

Wed, 15 Jul 2026 00:00:00 +0000

One thing which Go does a lot better than Python is single binary deployments. As an experiment I thought, why not have a way to package up Go as part of a Python package, similar to maturin - and also have a way to spin up a Python webserver that is packaged as a Go binary.

The results were definitely interesting:

Go binary had 9x more throughput than stdlib Python’s http library, and ~5x more throughput than FastAPI
Idle memroy usage was `3x higher for FastAPI, and the peak memory usage was ~2x higher than Go binary

Of course the pocket python restriction may be too much for more complex applications.

OpenCV 5 Python Bindings Is Here

Wed, 01 Jul 2026 00:00:00 +0000

OpenCV 5 Python Bindings Is Here

July 2026

OpenCV 5 for Python has finally been released to pypi and comes with QoL for running large models through their pipeline. One interesting way to use this pipeline is to use SAM model with LaMa together in a single code base

1sam_result = sam_segment(img)
2if sam_result is None:
3 print(" SAM failed, aborting")
4 return
5mask, point_coords = sam_result
6
7inpainted = lama_inpaint(img, mask)

Where each of the functions are:

 1
 2def sam_segment(img, point_coords=None):
 3 """Segment object using SAM2.1 with point prompts."""
 4 encoder_path = MODELS_DIR / "sam_encoder_v2.onnx"
 5 decoder_path = MODELS_DIR / "sam_decoder_v2.onnx"
 6 if not encoder_path.exists() or not decoder_path.exists():
 7 print(f" [!] SAM models not found in {MODELS_DIR}")
 8 return None
 9
10 t0 = time.time()
11 h, w = img.shape[:2]
12
13 scale = SAM_IMAGE_SIZE / max(h, w)
14 new_h, new_w = int(h * scale), int(w * scale)
15 resized = cv.resize(img, (new_w, new_h), interpolation=cv.INTER_LINEAR)
16 padded = np.zeros((SAM_IMAGE_SIZE, SAM_IMAGE_SIZE, 3), dtype=np.uint8)
17 padded[:new_h, :new_w] = resized
18
19 pixel_values = padded.astype(np.float32) / 255.0
20 pixel_values = (pixel_values - [0.485, 0.456, 0.406]) / [0.229, 0.224, 0.225]
21 pixel_values = pixel_values.transpose(2, 0, 1)[np.newaxis]
22
23 encoder = cv.dnn.readNetFromONNX(str(encoder_path), engine=cv.dnn.ENGINE_NEW)
24 encoder.setInput(pixel_values, "image")
25 image_embed = encoder.forward("image_embed")
26 high_res_0 = encoder.forward("high_res_feats_0")
27 high_res_1 = encoder.forward("high_res_feats_1")
28
29 if point_coords is None:
30 point_coords = [(w // 2, h // 2)]
31 point_labels = [1] * len(point_coords)
32 print(f" Point prompts: {point_coords}")
33
34 scale_x, scale_y = new_w / w, new_h / h
35 pts = np.array([[[int(x * scale_x), int(y * scale_y)] for x, y in point_coords]], dtype=np.float32)
36 labels = np.array([point_labels], dtype=np.float32)
37
38 mask_input = np.zeros((1, 1, 256, 256), dtype=np.float32)
39 has_mask_input = np.array([0.0], dtype=np.float32)
40
41 decoder = cv.dnn.readNetFromONNX(str(decoder_path), engine=cv.dnn.ENGINE_AUTO)
42 decoder.setInput(image_embed, "image_embed")
43 decoder.setInput(high_res_0, "high_res_feats_0")
44 decoder.setInput(high_res_1, "high_res_feats_1")
45 decoder.setInput(pts, "point_coords")
46 decoder.setInput(labels, "point_labels")
47 decoder.setInput(mask_input, "mask_input")
48 decoder.setInput(has_mask_input, "has_mask_input")
49
50 masks = decoder.forward("masks")
51 iou_predictions = decoder.forward("iou_predictions")
52
53 best_idx, best_score = 0, -1
54 for i in range(masks.shape[1]):
55 sig = 1.0 / (1.0 + np.exp(-masks[0, i]))
56 area_ratio = sig.mean()
57 if 0.02 < area_ratio < 0.80:
58 score = iou_predictions[0, i]
59 if score > best_score:
60 best_score = score
61 best_idx = i
62 if best_score < 0:
63 for i in range(masks.shape[1]):
64 sig = 1.0 / (1.0 + np.exp(-masks[0, i]))
65 area_ratio = sig.mean()
66 if area_ratio < 0.95:
67 score = iou_predictions[0, i]
68 if score > best_score:
69 best_score = score
70 best_idx = i
71 if best_score < 0:
72 best_idx = int(np.argmax(iou_predictions[0]))
73
74 mask_logits = masks[0, best_idx]
75 mask = (1.0 / (1.0 + np.exp(-mask_logits)) > 0.5).astype(np.uint8) * 255
76 mask = cv.resize(mask, (w, h), interpolation=cv.INTER_NEAREST)
77
78 kernel = cv.getStructuringElement(cv.MORPH_ELLIPSE, (15, 15))
79 mask = cv.dilate(mask, kernel, iterations=3)
80
81 elapsed = time.time() - t0
82 coverage = (mask > 127).mean() * 100
83 print(f" SAM: IoU={iou_predictions[0, best_idx]:.3f}, coverage={coverage:.1f}% [{elapsed:.2f}s]")
84 return mask, point_coords

 1
 2def lama_inpaint(img, mask):
 3 """Remove object using LaMa inpainting model."""
 4 model_path = MODELS_DIR / "lama.onnx"
 5 if not model_path.exists():
 6 print(f" [!] LaMa model not found: {model_path}")
 7 return None
 8
 9 t0 = time.time()
10 h, w = img.shape[:2]
11
12 resized_img = cv.resize(img, (LAMA_MODEL_SIZE, LAMA_MODEL_SIZE))
13 resized_mask = cv.resize(mask, (LAMA_MODEL_SIZE, LAMA_MODEL_SIZE))
14 _, resized_mask = cv.threshold(resized_mask, 127, 255, cv.THRESH_BINARY)
15
16 image_blob = cv.dnn.blobFromImage(resized_img, 1 / 255.0, (LAMA_MODEL_SIZE, LAMA_MODEL_SIZE))
17 mask_blob = cv.dnn.blobFromImage(resized_mask, scalefactor=1.0, size=(LAMA_MODEL_SIZE, LAMA_MODEL_SIZE), mean=(0,), swapRB=False, crop=False)
18 mask_blob = (mask_blob > 0).astype(np.float32)
19
20 net = cv.dnn.readNetFromONNX(str(model_path), engine=cv.dnn.ENGINE_AUTO)
21 net.setInput(image_blob, "image")
22 net.setInput(mask_blob, "mask")
23 output = net.forward()
24
25 result = output[0]
26 result = np.transpose(result, (1, 2, 0))
27 result = np.clip(result, 0, 255).astype(np.uint8)
28 result = cv.resize(result, (w, h))
29
30 elapsed = time.time() - t0
31 print(f" LaMa: inpainting complete [{elapsed:.2f}s]")
32 return result

On Syntax-Guided Program Reduction

Mon, 01 Jun 2026 00:00:00 +0000

Program reduction is an interesting problem: given an objective (e.g., a unit test), can we automatically create the minimal viable program by deleting unnecessary code?

This repo (nappe) and PyPI package is an implementation of an existing approach with extensions to solve this. As this problem is NP-hard, it’s not surprising that it is a tad ’expensive’ to do this well. However, it is interesting as it tackles things like removing dead code which perhaps tools like ruff don’t succeed with.

Constrained Procedural Generation

Fri, 01 May 2026 00:00:00 +0000

Constrained Procedural Generation

I’ve always been interested in procedural generation, the maps and algorithms to make ‘realistic’ and ‘dynamic’ environments. This post is more to post some musings and experiments.

One thing that I’ve found is that its often difficult to constrain the generation. For example if I want to use diamond-square, then the map itself needs to be square shape. How might we constraint or have a sliding window approach to generate non-square areas?

Testing Go with Monty (Python)

Wed, 01 Apr 2026 00:00:00 +0000

Testing Go with Monty (Python)

April 2026

Not much to say right now besides it works.

 1package main
 2
 3import (
 4	"context"
 5	"fmt"
 6	"log"
 7
 8	monty "github.com/ewhauser/gomonty"
 9)
10
11var a = `
12def add(x):
13 return x + 1
14
15add(x)
16`
17
18func main() {
19	runner, err := monty.New(a, monty.CompileOptions{
20		Inputs: []string{"x"},
21	})
22	if err != nil {
23		log.Fatal(err)
24	}
25
26	value, err := runner.Run(context.Background(), monty.RunOptions{Inputs: map[string]monty.Value{"x": monty.Int(10000)}})
27	if err != nil {
28		log.Fatal(err)
29	}
30
31	fmt.Println(value.Raw())
32}

It will be interesting if this enables greater scripting capabilities when integrating things into other languages.

Maya1 vs Kokoro vs Kitten TTS Review

Sun, 01 Mar 2026 00:00:00 +0000

Maya1 vs Kokoro vs Kitten TTS Review

March 2026

I finally got to test TTS models, and got them running locally with a variety of notes.

Kitten: advertised as the smallest model, its also the easiest to setup
Kokoro: an extremely good model for its size. I found getting it setup with the onnx wrapping to be the most straightforward (supports quants!)
Maya1: supports gguf. I ended up hosting it in LM Studio with a wrapper to have it working. This is the best quality but also the slowest

TLDR: Use Kokoro if you want a good balance of speed and quality, otherwise Maya1 is a suitable model if you’re willing to wait a bit

Python Debugger and VSCode

Sun, 01 Mar 2026 00:00:00 +0000

Python Debugger and VSCode

March 2026

I find myself copy + pasting (or ChatGPT) the debugging configuration more often than I would like specifically for pytest so replicating it here.

 1{
 2 "configurations": [
 3 {
 4 "name": "$NAME",
 5 "type": "debugpy",
 6 "request": "launch",
 7 "module": "pytest",
 8 "args": ["tests/test_name_of_file.py::test_name_of_func"],
 9 "justMyCode": false
10 }
11 ]
12}

Ralph Loop and Frequent Intentional Context Compaction

Sun, 01 Feb 2026 00:00:00 +0000

Ralph Loop and Frequent Intentional Context Compaction

February 2026

There’s been a few things I’ve been playing around and thinking about, specifically around how one might ‘implement’ the ideas.

Beads
Ralph Wiggum Loop
Context Compaction and Management

To that end, I have a single Python script example.

This aims to address a few items:

Manage cross tasks through the use of ’tickets’ (similar to beads), but in a more prescriptive way, where the tickets are created and actively closed outside of the agent loop (n.b. the agent can also create tickets, this way is more intentional which I’ve found works better for a ‘human’ reviewer, cause then the determinism guarentees that the ticket is seen and reviewable.
The Ralph Wiggum loop manages the completion by assessing the ticket queue and seeing whether or not it is complete or not
As part of injecting context to the Ralph Wiggum loop (since context is not preserved), we make use of Context Compaction workflow which is the ‘Research, Plan, Implement’ steps, whereby explicit guidance for researching, then planning is made to populate the context before finally implementing

In general this loop works well, particularly for more complex tasks. The Ralph loop guarentees that it will at least see the task to completion.

Some Python Helix Language Server Configurations

Sat, 01 Nov 2025 00:00:00 +0000

Some Python Helix Language Server Configurations

November 2025

Getting Helix to play ’nicely’ with custom configuration wasn’t too straightforward, specifically wanting ruff formatter to also do auto-fixes (e.g. fixing imports). I also wanted the binaries to be managed by uvx rather than polluting $PATH so needed a bit of customisation there as well.

Doing this ended up to be not too complicated, just need to find the correct setup.

On MacOS

In Appreciation of Go Generate

Mon, 01 Sep 2025 00:00:00 +0000

In Appreciation of Go Generate

September 2025

Go is a rather minimal language. It does away with macros and (direct) metaprogramming, but it does offer code generation as a first-class citizen via go:generate . On multiple counts, it is rather unassuming and underwhelming, after all the code generation needs to be directly committed for it to be used; there’s no generators or run time generation, but rather it forms part of the distribution.

Prompt Coding

Tue, 01 Jul 2025 00:00:00 +0000

Prompt Coding

July 2025

Perhaps another paradigm that is worth considering is just prompt coding, whereby a single prompt produces a script end to end, no edits, no rework. This means that you are just saving and rerunning the prompts rather than relying on (perhaps flaky and difficult to reproduce) diffs and iterations. This way also removes the reliance on AI IDEs, and you can use (free) chat interfaces to create code.

Inlay Hints and LSPs

Sun, 01 Jun 2025 00:00:00 +0000

Inlay Hints and LSPs

June 2025

It’s currently 2025, and there is a massive amount of interest in LLM/AI powered IDEs. But I think there is something more powerful - making good use of your LSPs. In particular inlay hints. Now inlay hints are a somewhat recent addition, but its something that helps with inferring type hints or annotating your code with these hints to reduce mental strain.

Python: pyrefly adds support by default
Rust: rust-analyzer adds support by default
Go: gopls adds support – you may need to enable it in settings

In VSCode settings it would look like:

Python MCP - Mounting to an Existing FastAPI ASGI Server

Tue, 01 Apr 2025 00:00:00 +0000

Python MCP - Mounting to an Existing FastAPI ASGI Server

April 2025

You can mount the SSE server to an existing FastAPI ASGI server dynamically. The way I’ve made it work is as follows:

 1sse = SseServerTransport(...)
 2
 3...
 4app.router.routes.append(Mount("/messages", app=sse.handle_post_message))
 5
 6@app.get("/sse")
 7async def handle_mcp_connection(request: Request):
 8 async with sse.connect(sse(request.scope, request.receive, request.send) as (
 9 read_stream,
10 write_stream,
11 ):
12 await mcp._mcp_server.run(
13 read_stream,
14 write_stream,
15 mcp._mcp_server.create_initialization_options(),
16 )

This seemed to work pretty well, along with having Redis as an intermediary broker for dealing with state.

Syncify Python Async Functions

Tue, 01 Apr 2025 00:00:00 +0000

Syncify Python Async Functions

April 2025

There’s a lot to unpack with Python shenanigans. Including why nest-asyncio even exists. Here is yet another pattern (note: you really should look into https://asyncer.tiangolo.com/ if it fits for you).

1def syncify(func, *args, **kwargs):
2 def wrapper(coro):
3 return asyncio.run(coro)
4
5 with ThreadPoolExecutor(max_workers=1) as executor:
6 result = next(executor.map(wrapper, [func(*args, **kwargs)]))
7 return result

Which delegates/moves the execution to a threadpool to bypass potential issues. This is definitely not a ‘performant’ option, but it may save your skin.

I’ll point out in general, where your event loop is not nested, you could just use asyncio.run.

Setting SQL for Feature Transformations as a Standard

Sat, 01 Mar 2025 00:00:00 +0000

Setting SQL for Feature Transformations as a Standard

March 2025

So Spark’s SQLTransformer is probably the first (and only?) documented, formal, specification for doing SQL transformations specifically for machine learning preprocessing. I think that is interesting for a variety of reasons, with the biggest one being opportunities for standardisation, in particular for real-time flows. Having a well-optimised SQL transformation engine could be immensely valuation. The reason why this hasn’t occured is probably because industry standard today still relies on Python as the execution engine, however this because untenable in scenarios where Python is an inappropriate production programming language choice. At the same time, Spark is typically too expensive of a dependency to justify low latency workflows. Nevertheless lets quickly look at the specification and considerations for using the language with an alternative computation backend.

Python & TypeScript - in Review (2024)

Sun, 01 Dec 2024 00:00:00 +0000

Python & TypeScript - in Review (2024)

December 2024

One thing that I like to stress is the importance of tooling and relying on defaults. By being able to speak consistently within ones own projects or using commonly seen patterns reduces the mental overhead. These could be folder structures or idioms, especially things which permeate across different programming languages or frameworks.

Here are some of my thoughts on Python and TypeScript; coming from someone who is predominantly a Python developer and does minimal front-end work.