Ty: A fast Python type checker and language server

https://github.com/astral-sh/ty

by arathore • 1 year ago

916 287 1 year ago

github.com

tmvphil• 1 year ago

Just compared the time to check on a fairly large project:

- mypy (warm cache) 18s

- ty: 0.5s (and found 3500 errors)

They've done it again.

mil226• 1 year ago

Great, but how does it compare to Pyright on the utility / performance curve? Pyright is mature and already very fast.

https://github.com/microsoft/pyright

nine_k• 1 year ago

Pyright is good, but it's quite a memory hog. (Yes, I have plenty of RAM on my machine. No, it has other uses during development, too.)

bjourne• 1 year ago

Pyright is only for type-checking and it lacks many features you'd expected from a modern LSP (I forgot which). Hence, it was forked and someone created basedpyright to fix it: https://github.com/DetachHead/basedpyright

insane_dreamer• 1 year ago

in my experience pyright is unable to infer many inherited object types (compared to PyCharm's type inference)

0xFF0123• 1 year ago

Pyright is incredibly slow in my experience, I've seen it take over a minute on complex codebases

mil226• 1 year ago

I tested it side-by-side on my ~100Kloc codebase.

Ty: 2.5 seconds, 1599 diagnostics, almost all of which are false positives

Pyright: 13.6 seconds, 10 errors, all of which are actually real errors

There's plenty of potential here, but Ty's type inference is just not as sophisticated as Pyright's at this time. That's not surprising given it hasn't even been released yet.

Whether Ty will still perform so much faster once all of Pyright's type inference abilities have been matched or implemented - well, that remains to be seen.

Pyright runs on Node, so I would expect it to be a little slower than Ty, but perhaps not by very much, since modern JS engines are already quite fast and perform within a factor of ~2-3x of Rust. That said, I'm rooting for Ty here, since even a 2-3x performance boost would be useful.

rtpg3• 1 year ago

I don't get why so many people go to bat for pyright, my experience with it has been pretty miserable. Open enough instances of it and you're in OOM city. It works, but often gets confused... and of course the absolute audacity of MSFT to say "let's go over to pyright, and by the way we're going to carve up some stuff and put it into pylance instead", meaning that it's totally not within the actual spirit of open source.

I would like to just not use it, but the existence of pyright as a _barely_ functional alternative really sucks the air out of other attempts' continued existence. Real "extend/extinguish" behavior from MSFT.

js2• 1 year ago

I have no doubt that it will be faster than mypy, but:

This project is still in development and is not ready for production use.

rybosome• 1 year ago

They’ve done it again.

Indeed they have. Similar improvement in performance on my side.

It is so fast that I thought it must have failed and not actually checked my whole project.

_carljm12• 1 year ago

(ty developer here)

This is an early preview of a pre-alpha tool, so I would expect a good chunk of those 3500 errors to be wrong at at this point :) Bug reports welcome!

joshdavham4• 1 year ago

Any rough estimates of how much faster you expect ty to be compared to mypy? I'd be super curious to know!

I was also one of those people who, when first trying Ruff, assumed that it didn't work the first time I ran it because of how fast it executed!

Handprint4469• 1 year ago

If you have uv installed, you can test it without installing by running:

  uvx ty check

wdroz• 1 year ago

You can also install it "globally" for your user with:

  uv tool install ty

Then you can use it anywhere

  ty check

heavyset_go• 1 year ago

Can also do

   uv tool run ty

If your $PATH sucks

simonw4• 1 year ago

Here's what I got against one of my larger open source projects:

  cd /tmp
  git clone https://github.com/simonw/sqlite-utils
  cd sqlite-utils
  uvx ty check

Here's the output: https://gist.github.com/simonw/a13e1720b03e23783ae668eca7f6f...

Adding "time uvx ty check" shows it took:

  uvx ty check  0.18s user 0.07s system 228% cpu 0.109 total

alexmolas• 1 year ago

how does it compare against mypy? is it much faster?

diggan• 1 year ago

I'm not sure if it's using your environment correctly, or are you expecting ~150 errors? Lots of import errors, and I'm guessing most of the other ones are errors because it couldn't infer what was imported.

scosman2• 1 year ago

Found 275 diagnostics

0.56s user 0.14s system 302% cpu 0.231 total

Damn that's fast. And zero issues in this project with pyright so curious that these are...

_carljm12• 1 year ago

There's a good chance many of the errors we emit are incorrect, at this stage. Lots to do still!

throwaway63467• 1 year ago

I was wondering when someone would write a type checker in Rust, seemed like an obvious thing to do given how slow mypy is.

joshdavham4• 1 year ago

There's Pyrefly if you wanna check it out: https://github.com/facebook/pyrefly

drcongo• 1 year ago

I've been looking forward to this for what seems like an age.

codydkdc• 1 year ago

how long is an age?

tough• 1 year ago

a year (probably)?

drewcoo• 1 year ago

An age is a long amount of time.

"An age" is probably an attempted cleaning-up of "a coon's age."

https://grammarist.com/usage/coons-age/

GuinansEyebrows• 1 year ago

in the tolkien legendarium they may be over 3000 years.

amelius3• 1 year ago

We're living in the information age. Not sure when or what the next age will be, but you get the idea.

nickagliano• 1 year ago

Interesting to see astral come out with this right around facebook’s release of “Pyrefly, a faster Python type checker written in Rust”.

Not making any sort of ethical statement, just interesting that rust keeps eating the python and JS tooling worlds.

tasn• 1 year ago

Astral announced it last year I think, so it's been a long time coming.

emptysea• 1 year ago

Also interesting, pyrefly uses Ruff’s parser!

https://github.com/facebook/pyrefly/blob/a8626110da034f8e513...

ipsum2• 1 year ago

Pyrefly is a rewrite of Pyre, a Python typechecker which has been around for 4-5 years. Pyre is the strictest type checker I've used, compared to mypy, but its kind of a pain to set up.

masklinn• 1 year ago

Interesting to see astral come out with this right around facebook’s release

Astral announced they were building a typechecker back in January: https://x.com/charliermarsh/status/1884651482009477368

zem2• 1 year ago

language tooling is a sweet spot for rust, for sure.

akdor1154• 1 year ago

Yeah.. Have either of the ty / pyrefly teams reached out to the other? I feel like the community does not really need two fast python type checkers.

(However, vc-backed astral probably need control over theirs to keep monetization options open, and Facebook probably need control over theirs so it can be targeted at Facebook's internal cool-but-non-standard python habits... Sigh.

Why do we have nice things? Money. Why can't we have nice things? Also money.)

_carljm12• 1 year ago

Yes, we've talked; I know a number of the pyrefly devs well. Ty had already been months in development when pyrefly development started. We discussed collaboration, but they decided they needed to do their own thing in order to move quickly and ensure it would serve their needs, which is totally reasonable.

kmacdough• 1 year ago

Yes, because this is precisely what rust has proven it is exceptional for: tooling that needs to be very correct and strives to be fast.

kodablah• 1 year ago

Fingers crossed this is/becomes extensible. Pyright and MyPy both suffer from lack of extensibility IMO (Pyright doesn't consider the use case and MyPy plugins come across as an afterthought with limited capabilities). There are many things that can be built on the back of type-checked AST.

andenacitelli2• 1 year ago

I’ve had this same thought. Ruff doesn’t support extensions / custom lint rules that I’m aware of, so maybe don’t get your hopes up.

the_mitsuhiko• 1 year ago

Not supporting plugins for a type checker to me is a plus. It’s quite frustrating that some Python projects only typecheck if you have plugins. That is a major source of frustration.

notatallshaw2• 1 year ago

Charlie already said in a podcast (https://www.youtube.com/watch?v=XVwpL_cAvrw) that they are not looking to make it extensible. That it's considered a feature that type checking works interchangeably across tools and projects.

Ruff's linting and formatting is more likely to get plugin/extension support at some point in the future.

WhyNotHugo• 1 year ago

I wonder how they'll handle situations like Django, which don't seem expressible via stubs.

dathinab7• 1 year ago

not specific to just your answer but why do people mention ruff?

Ruff is a linter which (intentionally) does close to no type checking.

So you pretty much have to pair it up with a type check to get any even just half way decent static code analysis.

aleksanb• 1 year ago

The way these type checkers get fast is usually by not supporting the crazy rich reality of realworld python code.

The reason we're stuck on mypy at work is because it's the only type checker that has a plugin for Django that properly manages to type check its crazy runtime generated methods.

I wish more python tooling took the TS approach of "what's in the wild IS the language", as opposed to a "we only typecheck the constructs we think you SHOULD be using".

mjr002• 1 year ago

The way these type checkers get fast is usually by not supporting the crazy rich reality of realworld python code.

Or in this case, writing it in Rust...

mypy is written in Python. People have forgotten that Python is really, really slow for CPU-intensive operations. Python's performance may not matter when you're writing web service code and the bottlenecks are database I/O and network calls, but for a tool that's loading up files, parsing into an AST, etc, it's no surprise that Rust/C/even Go would be an order of magnitude or two faster than Python.

uv and ruff have been fantastic for me. ty is definitely not production ready (I see several bizarre issues on a test codebase, such as claiming `datetime.UTC` doesn't exist) but I trust that Astral will match the "crazy reality" of real Python (which I agree, is very crazy).

_carljm12• 1 year ago

(ty developer here)

Currently we default to our oldest supported Python version, in which `datetime.UTC` really doesn't exist! Use `--python-version 3.12` on the CLI, or add a `ty.toml` with e.g.

``` [environment] python-version = "3.12" ```

And we'll find `datetime.UTC`.

We've discussed that this is probably the wrong default, and plan to change it.

dcreager13• 1 year ago

such as claiming `datetime.UTC` doesn't exist)

This is a known issue — we're currently defaulting to a conservative Python version, and `datetime.UTC` really doesn't exist until Python 3.11!

https://docs.python.org/3/library/datetime.html#datetime.UTC

We will probably change the default to "most recent supported Python version", but as mentioned elsewhere, this is very early and we're still working out these kinds of kinks!

davidfstr• 1 year ago

mypy is compiled using mypyc. It does not run as Python code.

miki1232112• 1 year ago

Python is slow for some CPU-intensive operations.

There are some extremely CPU-intensive low-level operations that you can easily write in C and expose as a Python API, like what Numpy and Pandas do. You can then write really efficient algorithms in pure Python. As long as those low-level operations are fast, those Python-only algorithms will also be fast.

I don't think this is necessarily "cheating" or "just calling disguised C functions." As an example, you can write an efficient linear regression algorithm with Numpy, even though there's nothing in Numpy that supports linear regression specifically, it's just one of the ways a Python programmer can arrange Numpy's low-level primitives. If you invent some new numerical algorithm to solve some esoteric problem in chemistry, you may be able to implement it efficiently in Python too, even if you're literally the first person ever writing it in any language.

The actual problem is that it's hard for people to get an intuition of which Python operations can be made fast and which can't, AST and file manipulation are sadly in the latter group.

shiandow• 1 year ago

CPU intensive is not quite the right metric. What python is slow at is all the extra administration that comes with basic stuff like accessing attributes and function calls.

This gives somewhat counterintuitive results where declaring and summing a whole list of integers in memory can be faster than a simple for loop with an iterator.

But yeah writing stuff in a different (compiled) language is often better if that means the python interpreter doesn't need to go through as many steps.

johnfn3• 1 year ago

In defense of mypy et al, Typescript had some of the greatest minds of our generation working for a decade+ on properly typing every insane form found in every random Javascript file. Microsoft has funded a team of great developers to hammer away at every obscure edge case imaginable. No other python checker can compare to the resources that TS had.

smithkl42• 1 year ago

And in the process, they ended up creating an extremely powerful type system that ~nobody outside of that original team can (fully) understand.

dathinab7• 1 year ago

It's even worse (for python).

TS might transpile to JS and can always be split into a js and type annotation file but is it's own language developed in tandem with the type check based on a holistisch approach to find how to type check then and then put it into the syntax and type checker.

Thats not true for python at all.

Python types where added as annotations to the language many years ago, but not in a holistic approach but in simplistic approach only adding some fundamental support and then extended bit by bit over the years (and not always consistently).

Furthermore this annotations are not limited to type checking which can confuse a type checker (through Annotated helps a lot, but is also verbose, wonder how long until there is a "Annotated" short syntax e.g. by impl @ on type or similar).

Basically what the type annotation feature was initially intended to be and what it is now differ quite a bit (dump example `list` vs. `List`, `Annotated` etc.).

This is made worse that a bunch of "magic" is deeply rooted in python, e.g. sub-classing `Enum`. Sure you have that in JS too, and it also doesn't work that well in TS (if you don't add annotation on the dynamically produced type).

Lastly TS is structurally typed, which allows handling a bunch of dynamic typing edge cases, while Python is, well, in-between. Duck-typing is (simplified) structural typing but `isinstance` is a common thing in Python and is nominal typing...

So yeah it's a mess in python and to make it worse there bunch of annoyances related to ambiguity or to many ways how to do a thing (e.g. re-exports+private modules, you can do that common coding pattern, but it sucks badly).

bvrmn2• 1 year ago

It's not mypy issue. Comparing to TS python typehints (spec wise) are a joke. It's started as bolted on adhoc solution and evolved quite chaotically. For example [1]. TS doesn't require a special decorator (sic!) to make your custom classes to be picked up by type checkers.

Or how make a wrapper function with args and kwargs to pass through?

[1] https://docs.python.org/3/library/typing.html#typing.datacla...

HideousKojima• 1 year ago

The way these type checkers get fast is usually by not supporting the crazy rich reality of realworld python code.

Nah, that's just part of the parade of excuses that comes out any time existing software solutions get smoked by a newcomer in performance, or when existing software gets more slow and bloated.

Here's one of many examples:

https://m.youtube.com/watch?v=GC-0tCy4P1U&pp=0gcJCdgAo7VqN5t...

Redoubts3• 1 year ago

Sure, but so far this has been a true criticism of every python type checker that isnt mypy that is production ready today

dathinab7• 1 year ago

the thing is most (all) of the type checkers including e.g. mypy _do not_ support most crazy python ...

not because they don't want to or because it's to slow

but because it's not really viable without fully executing module loading in a sandbox, which might seem viable until you realize that you still need to type check `__main__` modules etc. and that its a common trend in python to do configs by loading python modules and grabbing the module locals as keys of the config or loading some things might actually idk. initialize a GPU driver :sob: So it's kinda 100% guaranteed not possible to do fully correct type checking for all project :smh:

But also python is one of the slowest popular languages (and with a large margin to any not also "one of slowest" languages). Only by moving hot code into C++/Rust is it fast, which often is good enough, but a type checker is exactly this kind of software where this approach stops working.

amelius3• 1 year ago

I wish more python tooling

And not directly related, but I wish more python modules did proper checks with Valgrind before shipping.

lyu07282• 1 year ago

The CPython API is such a dumpster fire, even writing very simple modules the reference counting is very difficult to do correctly. The majority of python modules written in C are probably leaking memory somewhere but nobody knows.

TheTaytay• 1 year ago

Even Typescript is rewriting their compiler in Go. I think that the bottleneck is _actually_ the language sometimes.

(And uv and ruff have basically proved that at this point)

dathinab7• 1 year ago

through algorithmic improvements can also go a long way and if you are one of the first type checker which have to figure out the mess the python type annotation system is you will vast a lot of time on figuring that out instead of refactoring it's architecture to allow for algorithmic improvements

which brings us to another python issue, python is quite bad at such huge refactoring even with type checkers

but yeah python is by far the slowest widely used language, and for some use cases you can side step it by placing most hot code in C++/Rust extension modules, (or don't care because you are much much more network latency bound) but a type checker probably doesn't belong into that category

davedx5• 1 year ago

Can mypy type check SQLAlchemy somehow? That's what caused me to give up on Python type checking recently

lukaslalinsky• 1 year ago

SQLAlchemy 2.x has direct support for mypy, it works out of the box, no longer needing mypy plugins. Many things in SQLAlchemy as are still dynamic and can't be type checked, but the native support works great where it can.

collinmanderson2• 1 year ago

I also mentioned this up-thread, but https://pypi.org/project/django-types/ is compatible with pyright without plugins, so it should theoretically work with ty. It's not quite as good as the mypy-django plugin but it still catches a lot.

krupan• 1 year ago

Have these guys figured out how to make money yet?

dcreager13• 1 year ago

We're going to set up a lemonade stand in the main hall at PyCon next week

digdugdirk3• 1 year ago

Fingers crossed this isn't a joke.

all2• 1 year ago

This might actually be a decent business model. Sell hard goods to fund your habit of making excellent software tools.

joshdavham4• 1 year ago

I'm curious to see what Astral will cook up! I assume they'll probably eventually create some sort of paid devtool service.

With that being said, the worst case scenario is that they go caput, but that still leaves the python community with a set of incredible new rust-based tools. So definitely a net win for the python community either way!

__MatrixMan__3• 1 year ago

If they're making our lives better, perhaps the question is whether we've figured out how to pay them yet.

codr73• 1 year ago

From my experience it's VERY rare for people to pay for anything unless they're forced, I do the same thing even though I'm very aware of the need for compensating creators.

Talk is cheap, and people talk a lot about supporting projects.

Maybe if we could make some kind of statistics over the number of projects that were abandoned because maintainers didn't feel like working and dealing with random people for free anymore. Make the consequences of freeloading visible somehow.

never_inline• 1 year ago

They might pivot to some enterprise value added services. Probably around SAST - think sonarqube.

zanie5• 1 year ago

:wave:

Looks like you found the not-so-secret repository we're using to prepare for a broader announcement :)

Please be aware this is pre-alpha software. The current version is 0.0.0a6 and the releases so far are all in service of validating our release process. We're excited to get this in people's hands, but want to set the expectation that we still have a lot of work left to do before this is production ready.

Stay tuned for more for news in the near future!

(... I work at Astral)

theLiminator2• 1 year ago

Curious if this means it'll be released as a separate binary than ruff? I personally feel like having it within ruff is much nicer for ensuring that we have a consistent set of dependencies that play nicely with each other. Though I guess because a type checker doesn't mutate the files maybe that's not a real concern (vs formatting/linting with --fix).

zanie5• 1 year ago

It'll be separate (at least to start) — we want to be able to iterate on it rapidly. Long-term, a consistent toolchain is definitely important and something we're thinking about.

skwashd• 1 year ago

+1 for (eventually) baking it ty into ruff. In my mind static type checking is a form of linting.

For years I pushed black for formatting code. Once formatting was baked into ruff I ditched black. Having fewer dependencies to track and update simplifies my life and shortens my dependabot queue.

12_throw_away• 1 year ago

If you can say - are there any thoughts about implementing plugins / extension capabilities to keep type checking working even with libraries that aren't otherwise typecheckable?

(where "not otherwise typecheckable" means types that can't be expressed with stubs - e.g., Django, dataclasses pre-PEP-681, pytest fixtures, etc.)

dcreager13• 1 year ago

At least for the moment, we aren't planning on a plugin architecture. We do recognize that there are some popular libraries and code patterns that aren't easily (or at all) typeable with the current state of the typing spec. We feel it would be more useful to help drive changes to the typing spec where we can, so that other type checkers can also benefit; and/or implement workarounds for the most popular libraries directly in ty, so that a library author doesn't have to rely on their downstream consumers installing a particular set of plugins to get good type-checker results.

(It's also more difficult to support plugins effectively in a type checker like ty, than in a linter like ruff, since any non-trivial use case would likely require deep changes to how we represent types and how we implement type inference. That's not something that lends itself to a couple of simple hook extension points.)

danlamanna2• 1 year ago

I also asked this question here: https://github.com/astral-sh/ruff/discussions/15149#discussi....

collinmanderson2• 1 year ago

https://pypi.org/project/django-types/ is compatible with pyright without plugins, so it should theoretically work with ty. It might not check as much as mypy though especially with values() querysets.

digdugdirk3• 1 year ago

Cool! Out of curiosity, what's the bedrock that's used to determine what the fundamental python AST objects are? I'm wondering what the "single source of truth" is, if you will.

Is this all based off a spec that python provides? If so, what does that look like?

Or do you "recode" the python language in rust, then use rust features to parse the python files?

Regardless of how it's done - This is a really fascinating project, and I'm really glad you guys are doing it!

dcreager13• 1 year ago

There is a formal grammar defined in the CPython repo, implemented in a language called ASDL:

https://github.com/python/cpython/blob/main/Parser/Python.as...

ty uses the same AST and parser as ruff. We don't use the ASDL grammar directly, because we store a few syntax nodes differently internally than how they're represented upstream. Our parser is hand-written in Rust. At first, our AST was also entirely hand-written, though we're moving in the direction of auto-generating more of it from a declarative grammar.

https://github.com/astral-sh/ruff/issues/15655

https://github.com/astral-sh/ruff/tree/main/crates/ruff_pyth...

https://github.com/astral-sh/ruff/blob/main/crates/ruff_pyth...

zanie5• 1 year ago

As in, how are we parsing the Python code into an AST?

CPython uses a generated parser. The grammar is defined in https://github.com/python/cpython/blob/main/Grammar/python.g... which is used to generate the specification at https://docs.python.org/3/reference/grammar.html#full-gramma...

We use a hand-written parser, in Rust, based on the specification. We've written that previously at https://astral.sh/blog/ruff-v0.4.0#a-hand-written-parser

BewareTheYiga2• 1 year ago

For pre-alpha software it's working fantastic for my project. I thought I type annotated it well, but Ty had quite a lot of feedback for me. Great job and I can't wait until this is released.

IshKebab3• 1 year ago

Had you checked it with Pyright previously?

ZiiS2• 1 year ago

Pointlessmy anal; but 0.0.0a6 is very strongly indicative of the sixth alpha release. Pre-alpha are much better as .dev releases.

usr9012809• 1 year ago

Pre-alpha are much better as .dev releases.

No, they are correctly using semantic versioning to indicate pre-alpha releases. https://github.com/astral-sh/ty/releases https://semver.org/

fastball2• 1 year ago

It is the sixth alpha release. They haven't yet released a stable version – this is their sixth alpha release before that.

What am I missing here?

davedx5• 1 year ago

What might, possibly, redeem Python in my eyes as a potential language for making production applications (something that today, it is most certainly not) would be if the type checker worked across the broader ecosystem of common Python packages.

For example, as my recent struggles showed, SQLAlchemy breaks `pyright` in all kinds of ways. Compared with how other 'dynamic' ORMs like Prisma interact with types, it's just a disaster and makes type checking applications that use it almost pointless.

How does Ty play with SQLAlchemy?

jakewins• 1 year ago

My experience is this is nearly impossible, the solution is new packages written after typing was introduced.

I don’t know about SQLAlchemy, but for libraries like pandas I just don’t see how it can be done, and so people are actively replacing them with modern typed alternatives

wpeterw• 1 year ago

You mean Python is not a language for production applications ?

ukblewis• 1 year ago

Have you tried SQLModel?

pjmlp4• 1 year ago

For me, until it gets a production quality JIT, or PyPy and GraalPY get more community love, it remains a scripting language for learning on how to program, automating OS and applications tasks.

reubenmorais2• 1 year ago

This is a weakness of the Python typing system and not necessarily of individual typecheckers. Pyright has a policy of only implementing what's standardized, and the Python type system is simply inadequate to annotate most real world Python code out there. It's been years now and something as basic as properly typing kwargs is still not supported.

Ty could solve this if they rebel and decide to ignore the Python typing standards, which I honestly would appreciate, but if they take the sensible approach and follow the standards, it won't change anything.

bootsmann• 1 year ago

Only tangentially related but does anyone else here get very bothered when looking at the SQLAlchemy documentation? It seems so hard to find what kind of magic incantation you need to do in which order when trying to do a somewhat non-trivial query and I often just write the SQL I want and then tell chatGPT to rewrite it to SQLAlchemy operations but thats not really a sustainable solution.

melodyogonna2• 1 year ago

What version of SQLAlchemy? SQLAlchemy v2 is built with with type-hinting support, I didn't have any issues with it when I used it few months ago

opem• 1 year ago

Finally the missing puzzle piece from the astral toolchain is here! <3

simlevesque• 1 year ago

I installed it in VSCode and removed Mypy, I haven't looked back: https://marketplace.visualstudio.com/items/?itemName=astral-...

tayo42• 1 year ago

Curious why so many people want to implement type checkers for python? What problems are being solved that aren't covered already?

simonw4• 1 year ago

Speed.

alexwaygood2• 1 year ago

That's a big part of it, but there are also several areas where we're trying to innovate on functionality as well as speed. I'd personally be pretty disappointed if the only thing we had to offer at the end of all this was a type checker where the only value add was speed. We've also got first-class support for intersection types, and quite a different model to other type checkers regarding when and whether redefinitions are allowed, for example. We believe there are significant areas where typing can be made more usable and easily adoptable than it is today.

mvieira38• 1 year ago

The ones that are around are slow, and working with untyped Python is a pain in large codebases

dathinab7• 1 year ago

1. complete type checking

in python eco system you have linters like ruff which do hardly any type checking and type checkers like mypy which do try to approach complete type checking, but still are absurdly full of holes

2. speed

any of the "established" type checkers either are supper slow (e.g. mypy) so you only run it like once before commit instead of "life" or do fail to properly type check so many things that if you have a requirement for "adequate static code analysis" they reliably fail that requirement (which might result in a legal liability, but even if not is supper bad for reliable code and long term maintenance)

also probably priorities are switched with 1st speed then closing holes as the later part is really hard due to how a mess python typing is (but in many code bases most code won't run into this holes so it's okay, well except if you idk. use pyalchemy as "ORM" subclassing base model (just don't terrible idea)).

silverwind• 1 year ago

Existing python typecheckers are bad, slow and their communities are fragmented. If the community would agree on a single good and fast type checker, everyone will benefit.

f311a• 1 year ago

Does it support go to definition and other lsp features?

dcreager13• 1 year ago

We do plan to provide an LSP server and VS Code plugin, which will support GTD etc. Though as several others have pointed out (e.g. https://news.ycombinator.com/item?id=43919354), it's still very early days for ty, so we don't have concrete release announcements for that yet.

darkteflon2• 1 year ago

The VS Code extension is linked in one of the above comments. Accepting that it’s early days and all, but … if someone _really_ hated Pylance, could they replace it with ty for hobby projects and get most of the same headline functionality?

Thanks for all your great work! Love ruff, rye/uv.

cristea• 1 year ago

Will it support Django stubs? Only blocker for my company to switch

joejoo• 1 year ago

Astral killing it with the Python tooling.

rexledesma2• 1 year ago

Very excited to have a new fully featured Python language server working in both vscode and vscode forks (e.g. Windsurf, Cursor).

Pylance is borked on these forked distributions, so having a new solid alternative here that doesn't involve adopting yet another forked Pyright implementation (BasedPyright, Cursor Pyright, Windsurf Pyright, ...) sounds great to me.

maxloh• 1 year ago

You should try basedpyright: https://docs.basedpyright.com/latest/

basedpyright re-implements many features exclusive to pylance - microsoft's closed-source extension that can't be used outside of vscode.

rexledesma2• 1 year ago

I mentioned it in my initial comment. Ideally, I would like to use the same type checker/LSP for a language everywhere (any of my local editors, CI/CD).

This is especially important when working in a team setting.

It doesn't feel great to use a forked type checker/LSP that's not enforced in your org's CI/CD. And it also doesn't feel great to force the forked type checker onto the entire organization when only a subset of folks may be using a forked vscode editor.

ngoldbaum2• 1 year ago

I gave away the “ty” project name on pypi to Astral a week or so ago. I wanted to use it for a joke a few years ago but this is a much better use for a two letter project name. They agreed to make a donation to the PSF to demonstrate their gratefulness.

Celeo• 1 year ago

I love this outcome; kudos to you and Astral both!

swyx2• 1 year ago

thanks for not charging obnoxious amounts for package names!

smitty1e• 1 year ago

ty--thank you

_carljm12• 1 year ago

Yes, thank you for your graciousness and generosity, very much appreciated.

rrszynka• 1 year ago

nice! what was the planned joke?

ngoldbaum2• 1 year ago

Either something about beanie babies or something riffing on "thank you". Couldn't ever make up my mind then basically forgot about it.

urbandw311er3• 1 year ago

It’s like when we hit a new month the quota of “talk about Rust” credits is renewed.

andenacitelli2• 1 year ago

Say what you want, Astral ships impressively fast and their stuff works well. Python has been looking for better tooling for a long time.

rc00• 1 year ago

The timing of the recent batch of propaganda makes it hard to believe it's not coordinated. I wouldn't suggest paid actors but maybe just an attempt to counter some fairly visible and negative recent takes. The amount of "I love Rust but" comments make it hard to take the commentary seriously too.

Philpax3• 1 year ago

Is it really that hard to believe that people like the language and the problems it solves for them?

joshdavham4• 1 year ago

Any plans to create an official ty github action? I've been loving the ruff github action.

sestep• 1 year ago

Is this the same thing as Red Knot?

_carljm12• 1 year ago

Yes, red knot was the internal development code name; ty is the actual name.

robertwt7• 1 year ago

This will be similar to Typescript I assume? If so I can’t wait to use it!! I cant count how many times I’ve searched for “TS like in Python” since I’ve started working on Python codebase. TS is so awesome that I use it 100% on new projects. Ruff is also very good, but with this, large code base Python will be a breeze to work with

IshKebab3• 1 year ago

You can already use static type annotations in Python and check them with Pyright. This will just make it faster.

Also currently the Python IDE support (autocompletion, refactoring, etc.) in VSCode is provided by Pylance which is closed source, so this would provide an open source alternative to that.

briandw• 1 year ago

Looks good but it has the same issues that i have with mypy. Packages that don't include the type hints blow-up my process. In mypy i've come to terms with strategically ignoring packages or finding a package of type hints. Mypy is runs cleanly on my project but I get >800 errors with TY, mostly things like:

lint:unresolved-import: Cannot resolve imported module `pydantic` --> vartia/usr_id.py:4:6 | 2 | from typing import Optional, Any 3 | from enum import Enum 4 | from pydantic import BaseModel, ConfigDict

looking forward to the release version.

_carljm12• 1 year ago

The current version can handle importing pydantic without error just fine, but it probably can't find your virtualenv, so it doesn't know what third-party dependencies you have installed. Ty will discover your venv if it is in `.venv` in the project directory; otherwise you can help it out with the `--python` CLI flag.

alexwaygood2• 1 year ago

We'll also discover your venv if you: - Activate it manually (`source .venv/bin/activate`, etc.) - Set the `VIRTUAL_ENV` environment variable - Or use a command such as `uv run` or the equivalent from pdm/poetry/hatch to run ty (these project managers usually implicitly set the `VIRTUAL_ENV` variable to point to the project's virtual environment before executing any commands)

pizza• 1 year ago

Probably not a top priority but it would be really really cool if this thing had solid t-string support from the jump, to the extent that it’s feasible without actually executing code

rowanG077• 1 year ago

Recently I started a python project and I wanted to do it the "proper" way. mypy + pylint. But even on this small 15-20kloc program these tools are way to slow to do anything in realtime. It takes double digit seconds to have feedback. Way to long for an LSP. I'm honestly appalled the state of affairs is this bad. What the hell do people do with moderately or even large sized code bases?

Hasnep3• 1 year ago

They probably use (based)pyright which is much faster than mypy and ruff which is much much much faster than pylint.

mil226• 1 year ago

Pyright + Pylance + Ruff has been rock solid for me on my 100Kloc codebase for more than a year now. I use the VS Code extensions, and Pyright and Ruff are integrated into my pre-commit.

Affric• 1 year ago

See the thing about astral is that they get why Python has been successful in the first place:

When it was released it might have been one of the easiest to use languages.

The focus on tooling and making the tooling fast has been sharp. Seeing people recommend using non-astral tooling seems nuts at this point.

blibble• 1 year ago

prior to astral appearing, python's tooling has been beyond terrible, compared to say, Java's

astral have now replaced the awful pip with the fantastic uv

various awful linters with with the fantastic ruff

and now hopefully replacing the terrible type checkers (e.g. mypy) with a good one!

I hope they have the pypi backend on their list too, my kingdom for Maven Central in python!

danlamanna2• 1 year ago

I hope they have the pypi backend on their list too

IIRC they have floated the idea of private registries as a commercial offering in the past.

kokada• 1 year ago

prior to astral appearing, python's tooling has been beyond terrible, compared to say, Java's

I would concur with you if you said Go, Rust, Ruby, or even heck, PHP, but Java is probably the only language that I know that is in a situation even as bad as Python or even worse (at least for me definitely worse, because at least I understand Python tooling enough even when using it only for hobby projects, while I still don't understand Java tooling enough even after working professionally with JVM languages for 7+ years).

Java is the only language that I know except Python that has multiple project/package managers (Maven, Gradle, probably even more). It also has no concept of lock files in at least Maven/Gradle, and while resolution dependency in Maven/Gradle is supposed to be deterministic, from my experience it is anything but: just a few weeks ago we had a deployment that failed but worked locally/CI because of dependency resolution somehow pulled different versions of the same library.

Fighting dependency hell because different dependencies pull different version constraints is a pain (all Java/JVM projects that I ever worked had some manually pinned dependencies to either fix security issues or to fix broken dependency resolution), and don't even get me in the concept of Uber JARs (that we had to use in previous job because it was the only way to ensure that the dependency tree would be solved correctly; yes maybe it was by incompetence of the team that maintained our shared libraries, but the fact that we even got at that situation is unacceptable).

Oh, and also Gradle is "so fun": it is a DSL that has zero discovery (I had IntelliJ IDEA Ultimate and I could still not get it to auto-complete 60% of the time), so I would just blindly try to discover what where the inputs of the functions. The documentation didn't help because the DSL was so dynamic and every project would use it slightly different, so it was really difficult to discover a way to make it work for that specific project (the examples that I would find would be enough different from my current project that 90% of time it wouldn't work without changing something). Python at least has `pyproject.toml` nowadays, and the documentation from PyPA is good enough that you can understand what you want to do after reading it for 10 minutes.

screye2• 1 year ago

Even after all the praise, I'd say they're underrated.

Modular.ai raised $100 million to solve tangentially similar problems with python. Astral has already had a much larger impact, while providing better integration with less than 10% of that money.

swyx2• 1 year ago

disagree. modular has a different focus, to turn python into a systems language.

you could even say that astral and modular focus on two extreme ends of the developer experience spectrum - just making python tooling faster, vs making python-ish code faster.

melodyogonna2• 1 year ago

Modular raised $100 million to build heterogeneous AI infrastructure; building a language is just a subset of their goals.

zahlman2• 1 year ago

What issues do you have with the PyPI backend?

sakesun• 1 year ago

Credit should also go to Rye project by Armin Ronacher.

lemontheme4• 1 year ago

Yeah, iirc he was the first to go ‘what if we had cargo for python?’

canterburry2• 1 year ago

How about we just stop creating non type safe languages. Would save everyone so much hassle.

[bring on the downvotes]

codr73• 1 year ago

You're begging for it.

Not every situation calls for type safe languages, you're projecting a preference.

Hasnep3• 1 year ago

It's a bit late now that python has existed for a couple of decades

canterburry2• 1 year ago

How about put it on the roadmap for v4?

ljouhet• 1 year ago

uv is an incredible tool ; ty will be also. It's insanely fast

For now, I have some false negative warnings :

'global' variables are flagged as undefined `int:unresolved-reference: Name ... used when not defined` (yeah, it's bad, I know)

f(*args) flagged as missing arguments `lint:missing-argument: No arguments provided for required parameters ...`

pt_PT_guy• 1 year ago

don't forget ruff checker and formatter

tiltowait• 1 year ago

I've been looking forward to this since the original announcement (and before, really).

On the modest codebase I tried it on (14k LOC across 126 files), it runs in 149ms compared to 1.66s in pyright (both run via uvx <tool>). I couldn't get it to play nicely with a poetry project, but it works fine (obviously) in a uv project.

Definitely some false-positives, as expected. Interestingly, it seems to hate the `dict()` initializer (e.g. `dict(foo="bar")`).

SOLAR_FIELDS• 1 year ago

Only one order of magnitude? I thought it would be 2. Isn’t ruff 400x faster than the fastest Python alternative?

Philpax3• 1 year ago

A type checker is much more algorithmically bound / difficult to parallelise, but I'm sure there are still wins to be had in the future.

cyounkins• 1 year ago

How does Astral plan on making money?

preciousoo• 1 year ago

CI/CD products most likely, or something more futuristic in that line

nindalf• 1 year ago

CI/CD, private repositories, providing hosting. These are the options used by similar companies.

But I like that they’re focussing on creating something useful before chasing revenue. Once they’ve got a single tool that provides a consistent dev experience for Python developers and it’s widely adopted they should be able to pursue monetisation easily.

ivanbelenky• 1 year ago

holy shit this is happening

Sarios2• 1 year ago

Perhaps a silly question. Will ty be usable for getting semantical completions / suggestions. Similar to using pyright to get completions based on what's being written.

dcreager13• 1 year ago

We are planning on shipping an LSP front end, and the goal is for that to include code completions. Though to set expectations, they will probably not be that sophisticated on day one. There's a lot of interesting work that we could do here, but it will take time!

Sarios2• 1 year ago

You guys take your time and enjoy yourselves :). You have a proven record of making good tools, so if this part takes a while, let it take a while.

no_time• 1 year ago

Awesome work. What is the business model for these astral tools? It’s a bit of a “waiting for the other shoe to drop” feeling after seeing the VC backing on the company page.

lemontheme4• 1 year ago

From what I’ve gathered (because I had similar concerns), the code is properly open source. In the very worst case, should there ever come a rug pull, it can be forked.

dcreager13• 1 year ago

The code is definitely open source from a licensing perspective, but we are also trying to ensure that a healthy community forms around our tools as well. We've been developing ty in the open for the last year or so, and it already includes significant work from external contributors. This is definitely not a project where only Astral-paid engineers can contribute.

pamelafox• 1 year ago

I am literally checking HackerNews while I wait for mypy to finish running, so I am excited to hear a faster type checker is on the way! Hope the error messages are also helpful.

dcreager13• 1 year ago

We're definitely thinking hard about the ergonomics of our error messages! We're drawing inspiration from rustc and miette for the diagnostic model, and are aiming for a quality bar on par with rustc for their content.

The-Ludwig• 1 year ago

If this will be only 50% as awesome as ruff or uv, it will be a future must-have for me.

hamandcheese• 1 year ago

Not the most fun question, but as I see Astral taking over the python ecosystem, I can't help but wonder: how do y'all plan to make money? It seems like you've taken VC funding, so monetization is inevitable.

renmillar4• 1 year ago

Yes, are they going for enterprise licensing or something similar to JetBrains' approach?

zanie5• 1 year ago

The plan remains the same as when the company was announced (https://astral.sh/blog/announcing-astral-the-company-behind-...) — paid services that build on and integrate with the free tooling.

TeeMassive• 1 year ago

Glad to see that we have the type-checking equivalent of Ruff!

dhruv3006• 1 year ago

Great job!

Ty: A fast Python type checker and language server

Related Stories