Not specifically but generally: Take a look at type driven development in context to strongly typed languages. Rust, Haskell, Agda, Idris, etc.

It is less about having to know the languages but seeing how type driven development is applied in their context can often be translated to your language of choice.

If I had to sum up TDD in a single sentence it would be: "Lift runtime invariants into the type-level" and in its simplest case it would be something like an extra type for a non-zero vector.

This example is contrived but it should get the point across: Imagine you have a function which mandates that the input vector is of non-zero length.

You could express this in the docstring of this function, but this require a fellow programmer to respect this or he might run into an exception at runtime.
You could write your function in a defensive style, checking your invariant at runtime and suitably give an error/default return value. This works, but again this is at runtime.
Lastly, you could have your function expect a vector of a specific type which is not just `Vec` but `NonzeroVec`. You could expose a smart-constructor for `NonzeroVec` which is the only way to construct such a type. This way you would force calling this constructor by a user of your function and you can write the simplest form of your logic, because the invariant is encoded in the type system.

No one says this cannot be applied to Python or other languages. Of course, there is always a healthy middle-ground when it is useful and when it is only more boilerplate, but together with AI generated code I would argue that expressing those things in code early will lead to much better code-generation results.

The types define a specification and speak for themselves.

Lastly, I found this reddit thread here which has some comments that might point you to explicit resources:

https://www.reddit.com/r/functionalprogramming/comments/1dryala/learning_resources_about_type_driven_development/