hi everyone!
after around $4k in token spend and some crying, i finally managed to port effect-ts to python. i'm calling it pyfect.
you might be thinking, why would anyone do this?
well, i absolutely loved working with effect when developing in typescript. the way it handles errors, dependencies, concurrency, and composing complex applications just clicked for me.
but there's one problem. most of my backend work, especially around ai, data processing, and computer vision, needed to be in python.
python has an incredible ecosystem for this kind of work, and switching everything over to typescript just wasn't practical.
so i went looking for something like effect, but for python.
i came across a few repos that were attempting something similar, but after digging into them, none offered the level of parity i was looking for.
so naturally, i decided to port it myself.
introducing pyfect
pyfect is an attempt to bring the effect-ts programming model to python while keeping the developer experience as close to the original as possible.
the idea is pretty simple: what if you could write python programs where the type system knows what your program returns, how it can fail, and which dependencies it needs?
that's what pyfect tries to do.
some of the things i've ported so far include:
- typed errors and error handling
- dependency injection using services and layers
- structured concurrency and fibers
- streams, schemas, and resource management
- retries, scheduling, and transactions
- http, sql, rpc, and ai integrations
and quite a bit more.
how close is it to effect?
this was probably the biggest challenge.
i didn't want something that just borrowed a few ideas from effect. i wanted to follow its behavior and api as closely as python would allow.
currently, pyfect has around 95% api coverage, with over 22,000 tests and effect's own test cases being used to verify parity.
there are still differences between python and typescript that can't be completely avoided, but the goal is to make the experience feel as familiar as possible.
why this matters for python backends
one of the things i really liked about effect was being able to reason about errors and dependencies before actually running the application.
with pyfect, pyright can catch unhandled errors and missing dependencies at type-checking time.
this becomes especially interesting when building larger backends, ai pipelines, or applications with lots of services and external integrations.
instead of discovering certain problems at runtime, you can catch them while developing.
should you use it?
if you're building python backends, especially anything involving ai, i'd love for you to give it a go.
i do want to preface this by saying that it's still in its early stages, so there are probably some wrinkles to iron out. i wouldn't recommend dropping it straight into production without evaluating it first.
but i'm excited to see what people think and where it could go.
you can install it with:
uv add pyfect-dev
github: https://github.com/tylergibbs1/pyfect
docs: https://pyfect.dev/docs
if you've used effect in typescript before, i'd especially love to hear your thoughts on the approach.
and if you haven't, maybe this will be a fun introduction to the effect programming model.
feedback, criticism, and contributions are all welcome!
