6 ms·
An Update on Pytype
- md3911027514 1y agoPytype was cool before Python type annotations became widespread. It seems to me like the industry is naturally moving toward native type annotations and linters and away from static analyzers like Pytype and mypy.
- underdeserver 1y agoPytype and mypy check native annotations.
- md3911027514 1y agoWell yes but with native annotations the linter you’re already using can do a lot of the type checking work so for many teams it’s not worth it to add Pytype or mypy
- underdeserver 1y agoI think this is for the best. I used Pytype at Google years ago and while it's well written and the team was responsive, ultimately Python is not well suited for type checking Python. It's compute intensive. I think the Ty people at Astral have the correct idea, and hope it'll work out. https://docs.astral.sh/ty/ https://docs.astral.sh/ty/
- zhikanbumai 1y agoIn theory, nothing prevents the pytype team at Google to develop a new backend in a different language. In practice, there is no longer a pytype team at Google [https://news.ycombinator.com/item?id=40171125 https://news.ycombinator.com/item?id=40171125], which I suspect is the real reason for the discontinuation.
- ASinclair 1y agoThere is still a team within Google in charge of this space.
- comex 1y agoTo be fair, even if there is/were a team, I don’t know that writing a new backend from scratch would be a good use of their time. pytype apparently started before mypy or any of the other Python type checkers existed. [1] But at this point there’s mypy, pyright, pyre/pyrefly, Ty, and probably more I’m not thinking of. It sounds more useful to collaborate with one of those existing projects than to write yet another new type checker. Especially when, in my experience, each checker produces slightly different results on the same code, effectively creating its own slightly different language dialect with the associated fragmentation cost. In theory that cost could be avoided through more rigorous standardization efforts to ensure all the checkers work exactly the same way. But that would also reduce the benefit of writing a new type checker, since there would be less room to innovate or differentiate. [1] https://news.ycombinator.com/item?id=19486938 https://news.ycombinator.com/item?id=19486938
- zem 1y agothere is a new python team, we met up with them at pycon and had some nice conversations. as a former pytype dev I will be the first to admit that maintaining it as a legacy project without the context of having developed it over the years would not have been a pleasant experience at all, but also pytype, while very powerful at what it did, definitely had some flaws that put it firmly in the last generation of type checkers. the current generation (mostly ty and pyrefly right now, though major props to pyright for being ahead of the curve) is moving towards fast, incremental type checking with LSP integration, and pytype was never going to get there. it's fundamentally a slow, batch-based type checker, which will catch a lot of errors in your project, but which will never be usable as an incremental type checker within your ide. add that to the fact that it had a different philosophy of type checking from most of the other major checkers and you had users facing the issue that their code would be checked one way by pyright in the ide, and then a subtly different way by pytype in the CI pipeline. I loved my time working on pytype, and I would like to see some of its features added to pyrefly, but it has definitely been superseded by now.
- LtWorf 1y agoI'm personally just staying away from startups anywhere in my dependencies.
- deleted 1y ago[deleted]
- deleted 1y ago[deleted]
- vovavili 1y agoThe cost of your dogmatic preference is your Python experience being more miserable than it should be. Astral's ruff and uv are widely adopted for a good reason, and there is no reason to think that ty will come any different.
- LtWorf 1y agoThere is a reason and a potential much bigger cost I'm avoiding, that you are conveniently ignoring.
- rhaps0dy 1y agoI've heard of `ty` too but recently I learned about Pyrefly, which is not in pre-production alpha, and is also Rust: https://pyrefly.org/ https://pyrefly.org/ Is there a good reason to avoid using Pyrefly?
- jolux 1y agoI believe Pyrefly is stricter, so it may be a better choice for new projects but harder to integrate into existing ones without type-checking.
- denis- 1y agoI have a medium-sized codebase that is all green when running mypy with the strictest configuration possible. Pyrefly spits put around 200 errors for the same codebase. Most errors are related to SQLAlchemy.
- rhaps0dy 1y agoI mean, sqlalchemy until very recently needed a mypy plugin to type correctly (https://docs.sqlalchemy.org/en/20/orm/extensions/mypy.html https://docs.sqlalchemy.org/en/20/orm/extensions/mypy.html), which was just deprecated in 2.0.0. Perhaps you should do the upgrade (https://docs.sqlalchemy.org/en/20/changelog/whatsnew_20.html#orm-declarative-models https://docs.sqlalchemy.org/en/20/changelog/whatsnew_20.html...) and try again?
- samwgoldman 1y ago(Pyrefly dev here) Thanks for trying it out! If you have any feedback or bug reports, please don't hesitate to file issues on GitHub or find us on Discord. We have some open issues for SQLAlchemy (like [1]). I'm definitely curious to hear if there are any gaps from your perspective, having an already strictly-typed codebase. 1. https://github.com/facebook/pyrefly/issues/954 https://github.com/facebook/pyrefly/issues/954
- diggan 1y ago> Is there a good reason to avoid using Pyrefly? Wouldn't the other way around be easier for finding good tools? Figure out what matters to you, inspect if the project fulfills those needs and then go with it after making sure it works well for you. Regardless, a comparison between the two was posted to HN not too long time ago: https://news.ycombinator.com/item?id=44107655 https://news.ycombinator.com/item?id=44107655
- kubb 1y agoMaybe they could do typechecking using an LLM agent? I'm sure they'd fund a team for that.
- mudkipdev 1y agoThis is the way
- randomNumber7 1y agoJust let it interpret the python code /S
- kubb 1y agoIt could also detect any bugs and fix them on the fly.
- mococa 1y agoAnother abandoned project from Google? Not surprised. Never trust on Google.
- silentsea90 1y agoPytype is used heavily inside Google so they bear the penalty likely more than you. Besides, py typing libraries is a dynamically changing landscape so it isn't anything out of the norm. Not everything is an abandoned project, and if anything Google abandons some projects well after the winners and losers are apparent eg Tensorflow.
- mococa 1y agoYou have no ideia how many projects from them I used to use and from day to night they drop the development. Google sucks.
- sito42 1y agoastral bags another one
- RS-232 1y agoIs ty more mature than pyright or mypy? I'm currently using pyright, but I'm going to migrate once ty and its vscode extension are given the "production ready" greenlight.
- sito42 1y agoat this stage I get very few false positives and it's so much easier to configure and use than pyright
- denis- 1y agoty still doesn't understand match + typing.assert_never pattern, last barrier for me to switching.
- marcyb5st 1y agoPersonal experience: if you use injector[1] with NewType so that you can give your primitive types a meaning and add them to your injection stack it completely fails. For example: ```python ModelName = NewType("ModelName", str) # You bind your string within a module: binder.bind(ModelName, to=ModelName(parsed_args.model_name)) # When you need it: model_name = injector.get(ModelName) # Here it fails, saying that you need "concrete" types or something similar ``` So while it is great already it definitely still has many rough edges still. But it is to be expected from alpha releases [1] https://pypi.org/project/injector/ https://pypi.org/project/injector/
- jdlyga 1y agoI'm surprised Google still maintained their own solution for this for so long. The standard for statically type checking Python nowadays is mypy.
- ipsum2 1y agoMypy is far too slow to type check a codebase like Google's. That's why Facebook, Google, and Microsoft have/had their own solutions.
- zzzeek 1y agopylance and others are great for IDE type checking as you go along, but when you ship your code off to the CI it's best to stick to mypy for the full automated run, since mypy is in some aspects a bit of the "reference implementation" for python typing (meaning, it's a good choice as the common denominator the code you ship will have with other code it interacts with).
- ipsum2 1y agoIdeally yes, but there's conflicts between the type checkers.
- joshuamorton 1y agoGoogle, Facebook, and Microsoft all maintain(ed) independent non-mypy typecheckers for internal and external uses that aren't served by mypy. The various features mypy didn't support include speed, type inference/graduality, and partial checking in the presence of syntax errors (for linter/interactive usecases and code completion).
- zem 1y agopytype had two features that made it uniquely suited to google's needs: 1. it had powerful type inference over partially or even completely unannotated code, which meant no one has to go back and annotate the very large pre-type-checking codebase. 2. it had a file-at-a-time architecture which was specifically meant to handle the large monorepo without trying to load an entire dependency tree into memory at once, while still doing cross-module analysis there were a couple of attempts to get mypy running within google, but the impedance mismatch was just too great.
- ccbncvnnccvbj 1y ago[flagged]
- froh 1y agoin the related FAQ https://github.com/google/pytype/issues/1925 https://github.com/google/pytype/issues/1925 they point explicitly to the future: > What alternatives can I consider? There are four Python static type checkers that can be considered: mypy and Pyright have been released to the community for a while and have well established user bases. Pyrefly, ty were announced recently at PyCon US 2025 and are in active development stage in the current time of August 2025 when this was written. mypy - https://github.com/python/mypy https://github.com/python/mypy Pyright - https://github.com/microsoft/pyright https://github.com/microsoft/pyright Pyrefly - https://github.com/facebook/pyrefly https://github.com/facebook/pyrefly ty - https://github.com/astral-sh/ty https://github.com/astral-sh/ty
- zem 1y agoex-pytype dev here - we knew this was coming and it's definitely the right thing to do, but it's still a little sad to see the end of an era. in particular, pytype's ability to do flow-based analysis across function boundaries (type checking calls to unannotated functions by symbolically executing the function body with the types of the call arguments) has not been implemented by any of the other checkers (again for good reasons; it's a performance hit and the world is moving towards annotations over pure inference anyway, but I still think it's a nice feature to have and makes for more powerful checking). as an aside, while I agree that bytecode-based analysis has its drawbacks, I think it's a tool worth having in the overall python toolbox. I spun off pycnite from pytype in the hope that anyone else who wanted to experiment with it would have an easier time getting started - https://github.com/google/pycnite https://github.com/google/pycnite I have recently jumped onto the "write python tooling in rust" bandwagon and might look into a rust reimplementation of pycnite at some point, because I still feel that bytecode analysis lets you reuse a lot of work the compiler has already done for you.
- almostgotcaught 1y ago> while I agree that bytecode-based analysis has its drawbacks abstract interpretation of the bytecode like y'all were doing is the only way to robustly do type inference in python. > https://github.com/google/pycnite https://github.com/google/pycnite there's also https://github.com/MatthieuDartiailh/bytecode https://github.com/MatthieuDartiailh/bytecode which is a good collection
- librasteve 1y ago
- yegle 1y agofwiw the original pytype team was laid off as part of laying off the Python team last year. Google lays off its Python team | Hacker News https://news.ycombinator.com/item?id=40171125 https://news.ycombinator.com/item?id=40171125
- instig007 1y agoScala 3: exists, https://docs.scala-lang.org/scala3/book/scala-features.html https://docs.scala-lang.org/scala3/book/scala-features.html Developers: mypy, pyright, pyrefly, ty, pypy, nogil, faster-python, sub-interpreters, free-threading, asyncio, ...
- vovavili 1y agoThis would have been a fair point had Scala 3 supported Python's packages and was compatible with Python's tooling. At the very least until Mojo is mature and open-sourced, there are simply no alternatives to pouring time and effort into making Python a better language.
- instig007 1y ago> This would have been a fair point had Scala 3 supported Python's packages It supports the entirety of JDK-compatible packages and FFI/JNI bindings, which is a fair point of the comparison. Not sure why you have to frame it around the idea of necessarily having to improve Python, as the JDK infra and tooling have been around for ages, available to be picked by the devs.
- ivanjermakov 1y agoBoth python language and its ecosystem are such a mess. Imagine the amount of human hours spent on tooling development trying to fix fundamental flaws in a language design.
- mgaunard 1y agotl;dr please use pyright instead
- wiseowise 1y agoDAE GOole killing another project?!!! (Apparently maintaining something completely free of charge for 13 years is not enough for online cannibals)