Improving Python Through PEPs and Protocols

你不需要逐个查看文件。

You don't have to look at the individual files.

现在可以直接从 PyPI 下载元数据，然后直接看这个就行。

And you can download metadata now directly from PyPI and just look at that.

对吧？

Right?

所以性能上不会像你为了看一个元数据文件，却要下载整整一吉字节的 PyTorch。

So the performance is not like you're downloading like one gig of PyTorch just to look at its metadata file.

你只需要下载那几KB的元数据，看看就行了。

You can just grab the little, like, kilobyte of metadata and look at that.

这就是我这么做的原因。

And so that's why I did it.

对吧？

Right?

我只是想，怎么才能把这些数据开放出来，让工具真正能用上？

Was just kind of how do we expose this data out so that tools can actually use it?

不管是 PY 的 API 在界面上直接提示你：你安装这个，就会得到这些内容。

Whether it's PY API showing it to you somehow in its UI just like, hey, if you install this, this is what you'll get.

还是工具在问：我到底该安装什么才能让这个东西跑起来？

Or tools being like, hey, how the heck do I find something to install to make this thing exist?

是的。

Yeah.

明白了。

Okay.

所以这事儿是来回拉扯的，说到底。

And So it's kinda coming and going, if you will.

没错。

Exactly.

两边都在互相推动。

It's it's both directions.

而且就像你说的，确实挺难的。

And then it's tough as you said.

对吧？

Right?

比如有人写了个通用工具，自己都没意识到已经这么做了，结果别人因为没考虑到这一点，直接用了同一个名字。

Like, if someone's got got kind of like a generic utility and didn't realize they'd done that and that someone said they might trample that name because they just happen not to think about the fact that Yeah.

另一个项目恰好也用了这个名字。

This other project happens to have that thing.

还有一种更糟糕的情况，有人故意抢注这个名称。

And then there's the malicious version of that too where somebody's trying to squat on that space potentially.

所以确实是这样。

So Yeah.

不过说实话，这种情况下，很多人根本不会说实话。

Although, let's be honest, chances are people are gonna lie in that case.

对吧？

Right?

因为根本没什么能阻止他们。

Because there's nothing Yeah.

强迫项目使用它，甚至遵循它的规范。

Forcing projects to use this or to even follow what they say.

所以我不会把安全问题说得太严重，但至少能帮你避免出错。

So it's not I wouldn't go too far into the whole security thing, but at least helps you Right.

别搞砸了。

Not mess up.

对吧？

Right?

这确实是项目在做正确的事。

It's definitely projects doing the right thing.

你不会不小心在 util 里覆盖掉它，或者你只是说，我要弄个叫 PIE 的通用模块。

You won't accidentally overwrite that under util or you just say, I'm gonna have a generic module named PIE.

是的。

Yeah.

而且我还要装个 PIE test。

And I'm also gonna install PIE test.

呃，抱歉，这个会有冲突。

Like, sorry, that's gonna conflict.

总得有人赢，有人输，这样可不行。

Someone's gonna win, someone's gonna lose, and that's not gonna work out well.

是的。

Yeah.

对。

Yeah.

你平时导入库的时候，比如导入 pandas 写成 pd 这种，经常这么干吗？

How often do you when you import things, we we talked a little bit about the, you know, import pandas as, you know, PD or whatever.

嗯，有这习惯。

Mhmm.

你自己会这么做吗？

Is that a common thing that that you do yourself?

不会。

No.

好的。

Okay.

不会。

No.

我只在数据科学领域看到有人这么用，就是缩写成 PD 这种方式。

I I only see that on the data science science side of the world of doing the as thing and shortening.

是的。

Yeah.

我从来不这么干。

I never do.

我个人的习惯是先导入整个模块，再从模块里导入具体的对象。

So I will say my personal practice for imports is I import to the module and then import to the objects in the module.

所以我不会这么做。

So I don't go Okay.

比如不会写成 from django.models import data model 这样的代码。

Like, I don't know, from django dot models import data model.

我通常是用 from Django import models，不过顺便说一下，这个导入名可能不太对，我得澄清一下。

I do I do from by the way, that might be the wrong import name just to be clear.

别给我发火气冲冲的消息啊。

Don't don't shoot me angry messages.

没错。

Exactly.

我会用 from Django import models 这种方式。

But I do from Django import models.

对吧？

Right?

我就到此为止，不再往下写了。

And I'd stop there.

除非真的有必要，比如名字冲突了，我才会再用 from ... import ... 的方式。

And I'd only use ads if I had to like clarify because it's gonna conflict with some name or something.

对。

Right.

但我这么做是为了让我写代码时更清楚地知道，嘿，这个东西不属于当前模块。

But I do that so that it's a little more obvious to me when I'm writing my code that, hey, this is not in this module.

这不是我写的代码。

It's not something I wrote.

它是从别的地方导入的。

It's coming from somewhere else.

明白了。

Okay.

对吧？

Right?

因为我并不指望每个人都给自己的名字加前缀，好让我可以直接导入。

Because I don't necessarily expect everyone to write their names with a prefix so that I can import that name directly.

对。

Right.

对吧？

Right?

比如Django就这么做，但世界上不是每个项目都会用前缀来明确区分。

Because like Django does that, but not every other project in the world does that prefixing to make it very clear.

所以如果我直接导入这个类或函数，那就很合理。

So if I import that class, that function directly, that makes sense.

对吧？

Right?

我最典型的例子就是random。

My canonical example is random.

如果你在代码里导入了一个random函数，而你已经往下写了好几百行，那这个random到底指的是哪个？

If you import a random function in some code and you're a couple 100 lines down away from your import statement, what random is it?

是secrets.random吗？

Is it secrets dot random?

是random.random吗？

Is it random dot random?

还是NumPy.random？

Is it NumPy dot random?

你的 random 到底是哪个啊？

Like, what is it your own random?

你正在用的是谁的 random？

Whose random are you working on?

再看 secrets.random，就很清楚了。

Versus, look at secrets dot random.

我知道自己用的是哪个 random 函数。

I know exactly what random function I'm dealing with.

是的。

Yeah.

没错。

So Yeah.

这说得通。

That makes sense.

我个人不这么做，但社区里确实有一大帮人一直这么用。

I I personally don't do it, but obviously, an entire side of the community does the as constantly.

是的。

Yeah.

对。

Yeah.

大多数项目其实并没有这种命名上的差异，所以PEP特别说明了，如果你的名字在标准化后和项目名一致，就不用纠结大小写的问题。

And most projects, I don't think really have this differential of names, which is why the PEP specifically says like, hey, if your name matches your project name when it's normalized, like, don't worry about capitalization stuff.

没错。

Right.

你没必要这么做。

You don't have to do it.

对吧？

Right?

反正你从来都不用非得这么做。

You don't have to ever do it anyway.

这是可选的。

It's optional.

但这样做对项目来说是个好习惯，就是如果你打算用这种命名方式，最好明确写下来，免得别人措手不及，也能让大家顺利使用。

But it's just a nice thing to give projects just like, hey, if you do this thing with the name, please please write it down so that no one's caught off guard and anyone can work with it appropriately.

这说得通。

That makes sense.

顺便说一句，别觉得奇怪，还没人见过这种做法在实际中出现。

Which by the way, don't don't want you to feel weird that they haven't seen this out in the wild yet.

正如你提到的，因为我们把核心元数据版本升级到了2.5。

As you mentioned, because we're this bumped the core metadata version to 2.5.

所以当我们提到核心元数据时，如果你查看源码包或者sdisk里的那个tar.gz文件，里面那个pkg-info文件就是。

So when I when we talk about core metadata here, if you look in a source distribution or sdisk, that tar dot gz file, that's the pkg dash info file.

明白了。

Okay.

而如果你看wheel文件，那个metadata文件就是。

And if you look in a wheel file, that's the metadata file.

你打开看看，里面会有一个版本号。

If look in there, you'll see that there's a version number on it.

要支持这个功能，得满足好几个条件。

And the deal is is for that to be supported, multiple things have to happen.

首先，PyPI 得接受它。

First, you have to have PyPI accept it.

对。

Right.

对吧？

Right?

不然的话，他们会直接拒绝，说不认识这个东西。

And because otherwise, they'll reject it saying, we don't know what that is.

实际上，他们用的是我参与贡献的一个项目，叫 packaging。

And they actually use a project I'm a contributor to called packaging.

名字倒是挺直白的，不过也容易让人搞混。

Very obviously named, but also makes talking about it a little confusing.

是的。

Yeah.

但 packaging 这个包或项目得先支持才行，因为 PyPI 正是靠它来验证元数据是否合法，有没有损坏或格式错误之类的。

But the packaging package or project needs to support it first because that's what PyPI actually uses to verify that the metadata is legit and not corrupted or mis malformed or whatever.

我们处理这类事情就是按这个流程来的。

This is our protocol for this stuff.

对。

Yeah.

所以整个流程得这么走：首先得让一个 PEP 被采纳，修改版本号。

So the way this all has to happen is first you get a PEP accepted that changes the version number.

等 PEP 通过了，就得给 packaging 提交一个 PR，更新代码，让它能正确识别这个新版本。

Once you get that, then you have to do a PR to packaging to get that updated so that it can be read appropriately.

然后这个更新还得同步到 warehouse 里，也就是 PyPI 的项目名称，让系统能认出这个新版本号。

That then has to be moved over and used in warehouse, which is the project name for PyPI, to then recognize that version number.

如果需要调整界面来配合的话，也得一起改。

And also if there has to be any UI changes to make that work.

等这些都搞定了，像 Twine 这样的工具才需要更新，才能支持上传新版本的包。

And then once that happens, then projects like Twine need to support it to be able to upload it.

然后所有的构建后端也得支持，不管是 PDM 后端、Hashlane、uv 构建、setuptools、flit，还是别的什么。

And then all of the build back ends need to support it, whether that's we're talking about like PDM back end, Hashlane, uv builds, setup tools, flit, whatever.

对。

Right.

你得选一个构建后端。

Choose your build backend.

它们还得能生成并识别这个字段。

They also then have to be able to generate it and recognize that field.

显然，这中间步骤不少。

So obviously a lot of steps.

对。

Right.

截至这次录音时，Twine 已经支持了。

And as of this recording, Twine now supports it.

我觉得他们还得发个新版本才能包含这个功能。

I think they have to do a release still with it in it, maybe.

现在这些构建后端都在等 Twine 的下一个版本发布，之后它们大多已经准备好拉取请求，随时可以合并使用。

And the build back ends then are, I think, all waiting for the next release of Twine, and then they all have a bunch of them have PRs ready to go once that can go out and be used.

不过 PyPI 本身已经支持这个功能了。

But PyPI does have support for it.

只是目前还没有任何一个后端主动去推动它。

It's just none of the back ends are pushing it.

其实这一切都是最近才发生的。

And this all happened actually fairly recently.

我前几天刚查过，就是为了准备这次对话。

I actually just looked it up the other day kind of in prep for this Yeah.

录音。

Recording.

我当时就想，现在大家对这个功能到底是什么态度？

And I was like, where do they all stand on this?

我其实没怎么跟进这些工具的后续，因为所有维护者本来就在同一个对话里。

I haven't I haven't been I don't I don't babysit the pest once they're in because all the tool maintainers are all part of the conversation anyway.

是的。

Yeah.

就是啊，没错。

And it's like, oh, yeah.

大家都已经准备好了拉取请求，一直在等 pip-tools 支持，等到了之后，又在等 Twine 支持。

Everyone's got PRs, and they were all waiting for pip pip r a to get it, and then they got it, and then they were waiting for Twain to get it.

现在 Twine 的主分支已经支持了。

And now Twain's got it on main.

所以我觉得他们现在都在等 Twine 发新版本，一发布就能把拉取请求更新上线。

And so I think they're all waiting for Twain to come out, then they'll convert their PRs and be ready to go.

我可能对 Twine 发布的时间判断错了。

I could even be wrong about the Twain release.

说不定已经发布了。

Maybe it's out.

不过我觉得应该还没正式发布。

I don't I don't think it's out quite yet.

但至少它已经上线了，随时可以使用。

But it's it's at least there on main and ready to go.

所以一切终于都安排好了，希望今年内，至少在需要的时候，大家都能用上。

So everything's finally lining up that hopefully shortly, sometime at least this year, everyone will be able to use it where it's appropriate.

不过话说回来，是的。

But once again Yeah.

不错。

Cool.

我觉得绝大多数人其实用不上。

I think the vast majority of people won't need it.

但一旦你真需要它，那肯定会很方便。

But for those when you do, it's gonna hopefully be handy.

是的。

Yeah.

有一类PEP，我之前一直对这个有点好奇。

So there's a section of PEPs that and I wondered about this.

对

Mhmm.

希望咱们能赶紧把这部分简单带过一下。

Hopefully, we can just cover this kind of quickly.

是啊

But Mhmm.

我大概是四年前开始注意到这个问题的，怎么教这个。

I started noticing it maybe, I don't four years ago, how to teach this.

是的

Yes.

这是新加入的吗？

Is that something that is new?

是最近加进去的吗？

Like, did it get added?

它一直都在吗？

Was it always there?

没有。

No.

它是后来加到PEP流程里的。

It did get added to the PEP process.

明白了。

Okay.

就像你说的，大概四年前左右吧。

As you said, maybe four four years ago or something.

明白了。

Okay.

所以我意识到这是个新加入的内容。

So I did recognize it as a new thing.

是的。

Yeah.

好的。

Okay.

是的

Yeah.

对

Yeah.

不是

No.

有时候会有人提出想法，比如怎么让PEP更容易

We occasionally someone will come up with ideas just like, how do we make PEPs easier to

两者

both

怎么说呢，怎么才能让关于PEP的讨论更顺畅？

have a basically, how do we make it easy to have a conversation about a PEP?

是的

Yeah.

对吧

Right?

因为Python增强提案的目的是记录一场讨论。

Because Python Enhancement Proposals are meant to record a conversation.

它的作用是记录围绕某个提议展开的对话，以便让相关人员做出决定：到底要不要采纳这个改动。

It's meant to record a conversation around a proposal to have something happen to then take it to someone to make a decision as to whether to say, yes, we wanna make that change or not.

没错。

Right.

对吧？

Right?

所以大家总在讨论，怎么让这些文档更容易理解，让阅读的人既能搞清楚内容、表达自己的观点——支持或反对，也能提出问题、寻求澄清，从而帮助完善文档，对吧？

So there's always talk about how do we make these documents easier to digest such that both people who are reading them to understand, to help express their opinions to support or not, or to ask questions to get clarification, then help make the document better Right.

不仅要让普通读者能看懂，决策者也得能看懂。

Can do that, but also the decision makers.

所以当时参与讨论的那些人，他们当然在内，但现在我们说的是那些没参与原始讨论的人。

So the people that were in the conversation, they all those people, but now we're talking maybe the people that are outside that conversation.

是的。

Yeah.

没错。

Exactly.

而且决策者也需要掌握所有信息，不用再去翻整个对话的细节。

And then also the people have to make the final decision having all the information in front of them so they don't have to go back and read all the details of the whole conversation.

对吧？

Right?

比如在指导委员会里

So like on the steering council

没错。

Right.

我那时候在委员会，就得跟上讨论的进度。

When I was on it, you try to keep up with the conversation.

但说到底，你真正关心的是PEP里的内容，因为开会时你讨论的正是这些。

Well, ultimately, what you really care about is what's in the PEP because that's what you're gonna talk about in your in in the meeting with in the for the steering council.

就是说，PEP里写的是什么，因为最终决定要做什么，就看这份文档。

It's like, okay, here's what the PEP says because that's ultimately going to be the document that leads to what's gonna happen.

对吧？

Right?

它最初是参考依据。

It's the reference initially.

顺便说一下，PEP一旦被采纳，就成了历史文件。

By the way, once PEPs are accepted, they're historical documents.

所以，如果你看到某个PEP和现在的实际情况对不上，别担心。

So don't worry if you ever read a PEP that doesn't seem to match what the real what the world is like today.

没错。

Right.

这很正常。

It's okay.

它就是一份历史文件。

It's it's historical document.

是的。

Yeah.

别担心这个。

Don't worry about it.

但关键是，该怎么教这个呢。

But the point is is, like, how to teach this.

对吧。

Right?

正如我们之前提到的，我们确实重视教育。

It as we talked about earlier, we do care about education.

其中一部分就是，我们要确保无论采纳什么，都认真考虑过：教别人这个会有多难？

And part of that is, like, how do we make sure that whatever we accept, we have thought through, like, how hard is this going to be to teach someone?

因为这关系到我们对这项决定可能带来影响的思考。

Because that kind of plays into thinking through the ramifications of this.

对吧。

Right?

比如，如果我们提出一个很难教给别人的东西

Like, if we ask something that's gonna be really hard to teach somebody

是的。

Yeah.

也许我们不该这么做。

Maybe we shouldn't do it.

对。

Right.

对吧？

Right?

如果教起来很困难，那真的值得吗？

Or if it's gonna be hard to teach, is it really worth it?

是的。

Yeah.

对每一位教育者来说，这种复杂性真的值得吗？

Is this truly worth that complication for every educator?

会被接受吗？

Will it be embraced?

是的。

Yeah.

对。

Yeah.

没错。

Exactly.

对吧？

Right?

比如，那位教授或老师要教学生这些东西，他们会恨我们还是感谢我们这么做呢？

Like, is that poor professor or teacher having to teach their students this going to hate us or love us for doing this?

对吧？

Right?

或者至少他们能理解，我知道这很难，但你从中能得到这些收获。

Or can they at least it's like, I know this is hard, but here's what you get out of it.

对吧？

Right?

就是啊。

Like Yeah.

老师真的能为这个做法辩解吗？

Could a teacher even justify this?

所以这也是部分原因，导致那段被删了。

So that's partially why that got edited.

再举个例子，我们调整了PEP中各部分的顺序，把理由部分放到了规范说明之后。

But like, as another example, we just changed the order of the fields, the sections in the PEP such that the rationale comes after the specification.

明白了。

Okay.

以前的顺序是先来个摘要，给你一段简短的概述，

Because the way the order used to go is just go abstract to give you the quick one paragraph blurb

是的。

Yeah.

让你能快速判断：这值不值得往下看。

So that you can kinda go, do I care or not?

是的。

Yeah.

我到底为什么要花这么多时间和精力，让这件事成为现实？

The the motivation as to why the heck am I putting in so much time and effort in my life to have this become a thing?

对。

Right.

以前的结构是先讲设计动机，再讲具体规范，这写起来总显得很别扭——比如，你还没读规范呢，我就得先解释为什么规范要这么设计。

And then it used to be the rationale as to the design of it and then the specification of the actual thing, which always led to some weird contortions when writing because like, okay, I haven't actually had you read the specification yet, but I have to give the rationale as to why I did the spec this way.

所以你不得不在动机或理由部分，先把规范的内容大概写一遍。

So you kinda have to, like, half write the spec out in the motivation in the, rationale section

明白。

Uh-huh.

然后到了规范部分，还得再写一遍。

And then do it again in the spec.

好的。

Okay.

现在顺序颠倒过来了。

That order has been reversed now.

现在你先说明为什么要这么做，接着给出具体规范，等规范写完之后，你才说：好吧。

Now after you give the rational as to why you're doing this, you get the very you give the specific spec, and then after you give the spec, you're like, okay.

既然你已经知道规范是什么了，那我来解释一下为什么这样设计。

Now that you know what the spec is, here's why I designed it this way.

这个改变其实才刚发生，大概两三个月前吧。

And that just happened, like, literally, I don't know, two months, three months ago.

真厉害。

Wow.

明白了。

Okay.

最近才改的啊。

Really recent change.

是的。

Yeah.

是的

Yeah.

对

Yeah.

明白

Okay.

今年肯定了

Definitely this year.

所以我们一直在调整它

So we're still we're always playing with it.

我们又重新投入进去了

We're sold to it again.

如果你听培训团队的说法，他们提到想优化PEP流程，让操作更顺畅

If you listen to the training council, they talk about wanting to improve the PEP process, make it easier to work with stuff.

这些改动正好和那些目标相关

And this is some of the stuff that kind of ties into it.

就是说，咱们干脆让写这些文档和理解起来都更简单点。

It's like, let's just make it easier to write these docs and understand them.

是的。

Yeah.

对。

Yeah.

完全同意。

Totally.

我想深入看看 PEP 816。

So I wanna dig into PEP 816.

我觉得这个可能会简短一点。

I think this one will be a little briefer.

也许吧。

Maybe.

不过也许吧。

But Maybe.

我们之前聊过 WASI 和 WASM，也就是 WebAssembly。

We've talked about WASI and WASM, WebAssembly.

对的。

Yep.

好几次对话都提到过这个话题。

Several of our conversations have been about it.

这次内容就简短一点。

And so this one is just short.

WASI 支持，就是 w a s I 的支持。

WASI support, w a s I support.

没错。

Mhmm.

我再把摘要读一遍，快速过一下。

I'll read the abstract again, kinda make it quick.

这份 PEP 说明了 CPython 对 WASI 的预期支持。

The PEP outlines the expected support for WASI by CPython.

它包含了足够的细节，让你知道在每个 CPython 版本中，应该支持哪个版本的 WASI 和 WASI SDK，而官方的 WASI 支持则在 PEP 11 中明确说明。

It contains enough details to know what WASI and WASI SDK version is expected to be supported for any release of CPython while official WASI support is specified in PEP 11.

对的。

Mhmm.

所以它的意思是，只要你用某个版本的 Python，就能清楚该用哪个版本的 WASI SDK，以及它应该支持哪些功能。

So it it's kind of saying, if you have a version of Python, you will know what target as far

作为

as

WASI SDK 的版本，你该用哪个，系统会明确告诉你。

WASI SDK you're expected to use and is expected to support.

之前有没有人遇到过这种情况，比如：

Was there an experience people had of like, hey.

我用的是 Python 3.13，结果这些东西根本没法用？

I'm using Python three thirteen, and this stuff just doesn't work?

还是说，之前的情况就像一片无法无天的荒野？

Or like, what was was it kinda like a Wild West situation?

当时到底发生了什么，让你觉得必须把这一点更明确地固定下来？

What was going on that you needed to kinda lock this more down?

主要是想提前把问题解决掉，别等它真的成了麻烦。

It it was more getting ahead of things before it became a problem.

明白了。

Okay.

说到WASI，至少在用C语言这类语言编译成WASI时，有两个关键版本需要注意。

So when it comes to WASI, there's kinda two key at least when you're compiling a C based programming language for WASI Yeah.

所谓的‘宿主’是运行程序的WASI运行时，而‘访客’则是运行在其中的程序本身。

As what's called a guest, because the host is the WASI runtime that runs the thing, and the guest is the thing running in it.

所以在WASI的术语里，Python就是访客，运行在WASM运行时这个宿主之上。

So Python is a guest in WASI nomenclature within the host of, like, WASM time.

明白了。

Okay.

所以关键在于，你得关注这两个版本号。

So the deal is there's two version numbers to care about.

有一个WASI版本。

There's the WASI version.

对。

Right.

它决定了这个运行环境能提供哪些功能。

And that defines basically what functionality is available to that guest.

目前我们用的是普遍称为P1或者预览版1的版本，你也可以勉强把它看作0.1版。

And right now, we're using what's called commonly called P one or preview one, or you can kind of squint and pretend it's 0.1.

好的。

Okay.

还有你所使用的WASI SDK版本。

And then there's the WASI SDK version you tied to.

这一点很重要，因为WASI SDK在ABI层面，也就是二进制层面，不保证向前或向后兼容。

And the reason that was important is the WASI SDK has no forwards or backwards compatibility guarantees at the ABI level, So at the binary level.

好的。

Okay.

对吧？

Right?

所以

So

这些就是我们支持的功能，不能再往上或往下兼容了。

This is these are the features we support, and there's no, like, moving up or down from here.

是的。

Yeah.

没错。

Exactly.

对吧？

Right?

如果他们改了某些 POSIX 级别的底层系统调用，那是允许的。

Like, we might if they change how some, like, POSIX level, low level system call thing works, they're allowed to.

如果你用 WASI SDK 32 编译的程序，不一定能在 WASI SDK 33 上正常运行，这完全没有保证。

And there's no guarantee that if you compiled for WASI SDK version 32, that would actually also work in WASI SDK 33.

好的。

Okay.

对吧？

Right?

我们的目标是最终为 WASI 实现 wheel 支持。

So the goal is to eventually have wheel support for WASI.

为此，我们得先让整个社区达成一致，确定大家都统一编译到哪个标准，因为现在这些标准根本对不上。

So in order to have that, we kind of need to agree as a community as to what we're all going to compile to because once again, they don't line up and agree.

比如说，我们让 NumPy 能在 WASI 上编译成功。

So let's say we got NumPy to compile for WASI.

但如果 NumPy 单方面决定，就用 WASI SDK 32 来支持 Python 3.15，

Well, if NumPy just decided, let's just do WASI SK 32 for Python three fifteen.

行吧？

Okay?

那其他领域的人，比如不是数据科学圈的，就麻烦了——毕竟数据科学圈在这方面组织得挺好的，大家都围绕特定的 SDK 和编译器版本来协调。

And then someone else that was like outside the data science community, because the data science community is really good about kind of organizing around this kind of thing around specific SDKs and compiler versions and stuff.

好的。

Okay.

另一个人却决定，你知道吗，我们就用29吧。

Someone else decided to go like, yeah, you know what?

不知道为什么，他们就选了29。

We're gonna do we're gonna do 29 for whatever reason.

这样一来，它们就未必能兼容了。

Well, now those don't necessarily work together.

没错。

Right.

没法同时加载它们。

You can't load them together.

没法把它们拼在一起。

You can't stitch them together.

对吧？

Right?

因为它们针对的是完全不同的东西，可能根本加载不了。

Because they're totally targeting different things and they might not load up.

好吧。

So Okay.

祝你好运。

Good luck.

其中一部分原因在于Python本身，也就是核心的CPython语言。

So part of it is is not somewhat is Python itself, the core CPython language.

没错。

But Yes.

这是希望其他打包工具的开发者能意识到：要是能支持Python的WebAssembly，那打包工具也跟着支持就好了。

It's it's for other developers of packaging to say, hey, it'd be great if you supported WebAssembly with Python, and your packaging did it too.

为了避免这么多麻烦，如果你打算把项目迁移到Python 3.15，那就用这个WASI SDK版本。

And in order to not have so many pain points, if you're gonna do you know, move your stuff to three fifteen as far as, you know, Python, you would use this WASI SDK version.

对。

Yes.

而且这样能确保 CPython 能在那个版本上正常编译。

Also, it makes sure that CPython actually compiles on that version.

明白了。

Okay.

比如，WASI SDK 新增一些功能时，会加入对某些 POSIX 函数的支持。

Like, there have been times when new features land in the WASI in WASI SDK that add, like, POSIX support for some function

明白了。

Okay.

是在 C 层面的。

At the c level.

但实现的方式跟我们预期的不一样。

And it's not implemented the way we expect it.

对吧？

Right?

我记不清具体是哪个版本了，但有一次 WASM SDK 升级，他们加了一个 POSIX 函数，结果跟我们想的完全不一样。

I can't remember what version it was, but there was a WASM SDK version bump where they implemented some some POSIX function and it didn't match up with what we expected.

是的

Uh-huh.

结果我们的测试失败了。

And we got test failures.

明白了。

Okay.

所以我不得不去处理，直接假设这个功能根本不存在。

So I actually had to go in and say, assume this is not this doesn't exist.

从 Python 的角度看，这个功能本来就是可选的。

It was optional from a Python perspective.

我还专门去联系了 WASI SDK 的开发团队，跟他们说：我们的测试套件——顺便说一句，如果有人需要一个符合 POSIX 标准的测试套件，CPython 做得非常好。

But I had to go, like, and I talked to the WASI SDK developers like, hey, our test suite, which by the way, if anyone ever needs a POSIX compliant test suite, CPython is very good at that.

因为年代久远，我们早就把各种情况都测过了。

Being this old, we have test everything.

明白了。

Okay.

如果你需要C编译器的测试套件，我们这儿也很强。

And also if you need a C Compiler test suite, we're pretty good too.

多亏了CPython，我亲自在GCC和LLVM里发现了不少bug。

I personally found bugs in both GCC and LLVM, thanks to CPython.

真的厉害。

So Wow.

我可不是在开玩笑。

I'm not kidding.

我就去找他们，说：我们的测试套件显示，这应该是正确的行为。

So I went to them and was like, hey, our test suite says this is how it should work.

他们说：如果你仔细看POSIX规范，其实并不要求这样。

It's like, well, if you read the POSI expect very specifically, it says this is not necessary.

但我们的预期就是这样，所以干脆在Python里把这个功能关掉。

Like, well, this is what we expect, so I'm gonna just turn it off for Python.

我就这么做了。

And I did.

然后测试就通过了。

And then the test suite passed.

关键是，如果你用这个 Python 版本为目标平台编译，测试套件里就会出现这个值。

But, like, point is if you compile Python for that target in that Python version, you get a test value in the test suite.

明白了。

Okay.

其他 Python 版本不会遇到这个问题，因为它们还没加入这个函数，不管是 SDK 的哪个版本都一样。

While other Python versions wouldn't have that problem with that with or with the SDK version of some other version because they hadn't had that function put in yet.

对吧？

Right?

所以这其实只是生态系统里的一次协调，为了将来在 PEP 里为 WASI 的轮子添加平台标签，我确实希望最终能做成，但同时我也想说，对于 CPython，我和团队是一体的——我就是‘我们’的一部分。

So it's only just coordination across the ecosystem for a future PEP to add wheel support by creating a platform tag for WASI wheels, which I do hope to eventually do, But it's also saying, hey, for CPython, I'm gonna we slash I, because I'm part of the we here.

我们确保 CPython 能用这个版本的 WASI SDK 正常编译。

Say, we're making sure that CPython can compile with this version of the WASI SDK.

我们不保证旧版本或新版本都能正常运行。

We make no guarantees that older versions will work and newer versions will work.

但至少这个版本，你可以拿去用，提交上去，应该是能正常运行的。

But at least this version, you can take it, you can file it, and it should work.

如果不行，就报个bug。

And if it doesn't, file a bug.

这确实是个bug。

It's a bug.

明白了。

Okay.

而对CPython本身来说，另一个关键点是WASI的版本。

And then but the really other key thing for CPython itself is that WASI version.

比如，还没正式发布的WASI 0.3版本，会加入套接字支持。

Because for instance, WASI 0.3, which isn't out quite yet, is adding sockets.

对吧？

Right?

而且在0.3.1版本里，还会逐步加入线程支持。

And it's also adding, eventually some threading support in zero point three point one, basically.

我觉得从技术上讲，这样并不会导致版本号升级，但 0.3 版本迟早也会加上线程支持。

I think it's technically not gonna be a version bump that way, but 0.3 will also be adding threads at some point.

好的。

Okay.

所以接下来的问题是，我们是不是要正式宣布支持 sockets？

So that's also gonna be like, okay, are we gonna say sockets are supported officially?

因为目前在 CPython 里，WASI 的 sockets 功能是被禁用的。

Because right now sockets are turned off in for WASI in CPython.

对。

Right.

正式地来说。

Officially.

但等这个功能上线后，我的计划是正式启用它，让 socket 支持成为官方功能。

But when that comes in, my plan is to turn it on officially so there is officially socket support.

不过如果我要这么做，就得确保自己能真正测试并让它正常运行。

But if I do that, I gotta make sure I can actually test it and work it.

我想能明确地说：是的，官方支持套接字，如果出现相关问题，我们能判断是咱们这边的问题还是WASI的问题，也知道该向谁提交bug报告。

I wanna be able to say like, yes, officially, if there's a bug with the socket support, we can either figure out if it's us or if it's WASI and who do we file the bug with, but we actually officially support it.

明白了。

Okay.

但现在的情况是：不，我们不支持套接字。

Versus right now, it's like, nope, we we don't support socket.

套接字根本不在支持范围内。

Socket is not a thing.

我们目前只支持WASI 1.0，也就是0.1版本，那个版本根本不包含套接字功能。

We only support WASI p one, which is 0.1, which has no socket in it.

所以就是：不行。

So it's just like, nope.

这事不考虑。

Not not going there.

压根儿就不在这范围里。

And it's just not it.

所以这本质上是记录决策过程以及我们最终采用哪个版本的方式。

So it's it's basically a way to document how the decision's made and what version we're gonna snap to Right.

同时也明确大家的预期，以及在什么情况下才可能更改这个版本号。

And kind of what the expectation is and what it would take to ever change that number after Okay.

一旦出现特殊情况。

Something happens.

所以这份PEP明确说了，等到beta一发布的时候。

So the PEP specifically says, come beta one Yeah.

只要主分支和构建机器人上用的是哪个WASI支持版本和WASI SDK版本，我们就用那个。

Whatever WASI support version support and WASI SDK version is in main plus on the build bots.

换句话说，我们最终会采用的就是当前主分支上的那个版本。

That is basically the version we're gonna go with.

如果出现不一致的情况，由负责WASI支持的维护者来决定如何处理。

If there's any discrepancy, it's at the discretion of the people who are listed as the maintainers of WASI support.

如果在beta一发布之后，你确实需要升级WASI SDK版本，那这个决定权在WASI支持的维护者手里。

If you need to change the WASI SDK version for some reason after beta one, that is the call of the maintainers of WASI support.

但如果你需要更改 WASI 版本，那可就麻烦多了。

But if you need to change the WASI version, because that's way more work.

对吧？

Right?

正如我所说，一旦我们支持 0.3 版，就会加入套接字功能。

As I said, like, once we support 0.3, we're gonna have sockets.

是的。

Yeah.

对吧？

Right?

这可不是个小跨越。

That's not a small leap.

这确实需要指导委员会批准。

That actually requires steering council approval.

明白了。

Okay.

因为我们现在改变的是对 CPython 所承诺支持的内容，这比 PEP SDK 的改动要大得多，PEP SDK 那个几乎只是个修复。

Because we're changing what we're promising we're gonna support in CPython at much greater level than PEP SDK where it's like, it's almost a bug fix.

明白了。

Alright.

对。

Yeah.

所以这基本上就是 PEP 里说的。

So that's basically what the PEP says.

然后你提到的 PEP 11，只是列出了支持的平台。

And then PEP 11, as you mentioned, that's just the PEP that lists platforms

支持的平台。

Supported platforms.

是的。

Yeah.

好的。

Okay.

没错。

Exactly.

所以这本质上是一个说明流程的PEP。

So it's just basically a PEP that outlines the process.

这确实是一个专门针对流程的PEP，因为我们有不同的PEP类型。

It's actually a process PEP specifically because we have different kinds of PEPs.

大多数都是标准类的。

Most are just standards track.

比如，当我为打包提出标准类PEP时。

Like, so when I forward standards track for packaging

对。

Yeah.

但我们也有流程类PEP，只是说明我们正在遵循的流程。

But we do have process PEPs that just say like, here's the process we are following for something.

而这次，正是这样。

And in this case Right.

这是我们目前在 CPython 中标准化 WASI 支持所遵循的流程。

This is the process we are following on how to standardize WASI support in CPython itself.

所以它目前是活跃状态，还没最终确定，因为还没完成。

And so it's active, not final, because it's not considered done.

它只是正在被积极推行中。

It's just considered actively in being enforced.

对。

Right.

而且支持级别是会动态调整的，有高低之分。

And there's actual levels of support that things move up and down

我们确实讨论过这一点。

that we've Yeah.

说来有点讽刺，写完这个 PEP 之后，我还没来得及把 beta 1 的支持细节写下来。

Discussed I will say, somewhat ironically, after writing this PEP, I have not gotten around to writing down the support for beta one.

我本来打算在 PEP 11 里写清楚 3.15.0 beta 1 的支持情况。

I thought three fifteen zero beta one in PEP 11 yet.

我待办事项里有这一项。

It's on my to do list.

但会是 PEP 1 和 WASI SDK 33，正好在 beta 1 发布的前一个周五推出的。

But it is gonna be p one and WASI SDK 33, which happened to come out the Friday before beta one hit.

所以幸运的是，我有足够时间把这部分完成。

So luckily, I had enough time to get that done in there.

我们有时间把所有内容都测试一遍，是的。

We got time to test it all and yeah.

我

I

对。

Yeah.

对。

Yeah.

关于这个，我有几个小问题。

Got a couple quick questions on that.

是的。

Yeah.

你提到过，当我想到 POSIX 时，我首先会想到文件系统相关的访问。

You talked about how when I think of POSIX, I think of access to mostly file system stuff.

比如，跨平台的访问，对吧。

Like, you know, access across, like Mhmm.

在计算机系统内部的那些操作。

That in in inside of a, you know, computer system.

线程。

Threads.

原来是这样，我明白了。

Is it does it go oh, okay.

它涉及的范围不止这些。

It goes beyond just that.

哦，确实如此。

Oh, yeah.

本应如此

Supposed to be

整个系统里的权限归属。

ownership across all of that.

谁能在哪儿做什么？

Like, who who can do what and where?

它是

It's

没错。

a Yeah.

比如线程。

So like, p threads.

如果你听过线程，那就是 POSIX 线程。

If you've ever heard of P threads, that's POSIX threads.

明白了。

Okay.

P就是这个意思。

That's what the P is.

对。

Yeah.

很多都跟文件系统有关，但更重要的是怎么跟操作系统交互。

A lot of it's file system, but it's also like how to talk to the OS.

明白了。

Okay.

它其实就是

It's a

很多内容都在于如何

lot of how how

说到底，核心就是怎么跟操作系统沟通。

it's it's basically how do you talk to the OS is really what it comes down to.

对吧？

Right?

是的

Yeah.

所以就是系统、线程，像PID啊、进程这些内容，所有这类东西。

So it's systems, threads, like PIDs, the process stuff, like all that kind stuff.

这些都是

That's all

POSIX。

POSIX.

很好。

Great.

所以Python拥有庞大的标准库，这是否也是帮助它覆盖这些不同方面的原因之一？

So the fact that Python is a large standard library, is that also one of the things that helps with, like, you're saying, making sure it covers all these different bases?

这算不算其中一个因素？

Is that maybe part of it?

是的

Yeah.

这确实是其中一部分。

It's definitely a part of it.

你看看 os 模块就知道了。

If you look at the OS module.

对吧？

Right?

是的。

Yeah.

里面的东西可多了。

A lot of stuff in there.

明白了。

Okay.

诸如此类。

Etcetera.

标准库中很多跨平台代码都需要基于 POSIX，因为这是在不同 Linux 发行版之间保持一致的唯一方式。

Various places where we try to write cross platform code in the standard library requires working with POSIX because that's the only consistent way to work across Linux distros.

对吧？

Right?

而且通常在 Mac 上也能用。

And usually also works with Mac.

然后就是 Windows 了。

And then there's Windows.

是的。

Yeah.

所以一般就是 POSIX 和 Windows 这两个目标平台。

And so usually, it's POSIX and Windows, and that's the two gs target.

通常这样就能通吃了，这也是为什么在 Unix 世界里，POSIX 作为标准这么方便。

And usually, that works across the board, which is why POSIX is so convenient to have in the world as a standard in the Unix world.

最后我想提一下这个，不过希望别扯太远。

The last thing I wanna kinda mention on this one, and hopefully, won't go too deep on this.

但是呢。

But k.

你对这个感兴趣的地方在哪里？

What is your interest in this?

也就是说，是什么让你对 WebAssembly 感到兴奋？

Like, what excites you about WebAssembly?

是它的潜力，现有的项目，还是未来的前景？

The potential of it, existing projects, the future of it.

我把浏览器看作一种能在手机、平板、电脑上运行的通用平台，对吧。

I understand the browser as this kinda universal thing that runs on a phone, a tablet, a computer Mhmm.

还有电视之类的设备。

Your TV, what have you.

我们之前大概提过这一点，但我想再问问，你到底为什么这么兴奋？

And I I think we briefly touched on this before, but, like, what is your excitement?

你为什么对这个这么投入？

Why why are you invested in this?

我以前在这档播客里说过，我接触 WebAssembly 的初衷，是想把 Python 带进浏览器。

I think I've said it on this podcast previously, but the reason I got into WebAssembly was to try to get Python into the browser.