ON PIP WHEEL FOR X86 HOW TO HANDLE THE

If pip doesn't find a wheel for your platform, it will try to compile pygame from source (see below). So what led me from not caring to learning as much as I could about wheel tags and what did I learn along the way? I get sucked into packaging projects too easilyWheels are available for x86 and x64 architectures on Linux and Windows, and for x64 on Mac. For someone like me whose personal projects are all written in pure Python, I never really paid much thought to what those tags meant since the wheel tags for my projects are all py3-none-any (you will find out what that means later in this post).

Be sure to upgrade to the latest versionFor some reason I want to help Python end up with a good packaging story. On Windows and on Mac OS X one must have a recent release of pip to retrieve the proper wheel from PyPI. Pip.exe install grpcio Windows users may need to invoke pip.exe from a command line ran as administrator.

The downloads tab contains an option components and that list contains an option to install the Command Line Tools.python -m pip install -U setuptools pip. If you use OSX 10.8 or earlier, open Xcode and then open the Xcode preferences. The next action depends on the OSX release you are using. A perfect example of this is PEP 518 and pyproject.toml: this didn't actually solve a problem I was having in general, I just knew it would be a good thing to have for packaging in the Python community and would help solve a problem that had existed for well over a decade.To install the Command Line Tools first install Xcode from the Mac App Store. But for some reason I still try to keep up with what is happening with the PyPA and that inevitably leads me into getting sucked into some new project on a semi-regular basis.

When looking at the APIs of all four versions it became apparent rather quickly that the module's feature API was rather small and most of the exposed API was actually for the module's own benefit. What was the state of things when I started?Digging into this and talking with PyPA folks I learned that there was a module named pep425tags which various projects used:Unfortunately every one of those projects had a vendored copy that had deviated from the original code. One of the gaps that I found in the outline was there was no way to easily tell what wheel to download from PyPI for a project as there wasn't a package to help with wheel tags. And so I outlined the steps to go from package and version name to installed package and figured out where the gaps were.

Compatibility tagsWhat a wheel filename is trying to communicate to you is what platform(s) it is compatible with without requiring that you open the file in any way. But before I dive into what I found out I should probably explain how wheel compatibility tags work. And so I used pip's output from its copy of pep425tags as my starting point.

Than the most general wheel that your platform supports. You want that because the assumption is if a wheel is more specific it will perform better, provide more options, etc. It also prevents filename collisions in cases where a project has 22 wheel files like numpy.As a consumer of wheels, what you're after is the most specific wheel which will work for your Python installation.

This represents the Python interpreter version the wheel is compatible with. InterpreterThe first tag is for the interpreter. You can also look at this from the inverse perspective and the wheel tags say what systems a wheel won't work on.And to communicate what wheels are compatible with what Python installation setups, a tag triple is used. There's always a possibility that a wheel won't work on a platform even if the tags match simply because there's a limit in how much information can be provided in a filename (and compatibility with compiled C code is surprisingly hard).

So if a wheel has a tag of py37 then it's compatible with any interpreter that supports Python 3.7.The py 'interpreter' is also often used to represent just the major version of Python, like py3 for wheels that are not strictly tied to a major/minor version of Python. This is why there's a py abbreviation to represent the Python language you can think of it like an abstract interpreter for a version of the language. The version number is meant to represent the major and minor version of the interpreter version, hence why PyPy3 has a version number that doesn't necessarily match the version of Python it implements.Now obviously it's possible to write Python code that is interpreter-agnostic and these example tags don't reflect that. For pp360 it means it's compatible with PyPy3 6.0. That means that if you see a tag for cp37 then it's considered compatible with CPython 3.7.

The various letter suffixes mean the following: The cp37 bit is just like in the interpreter tag: it represents the interpreter version that the wheel expects. This is traditionally a CPython-specific thing, but there's technically nothing stopping PyPy3 from declaring it supports CPython's API or even defining it's own ABI.Specifically for CPython 3.7, you may see the following ABI tags:The cp37* tags are the most common one for CPython-specific wheels, and specifically cp37m is what nearly all wheels on PyPI will be for CPython. ABIThe next tag is the ABI required of the Python interpreter.

PlatformThe platform tag represents what operating system a wheel supports. This is typically seen with py interpreter tags since you shouldn't care about what ABI an interpreter supports if you're targeting just the Python language and not a specific interpreter. That has led to us accidentally expanding it on numerous occasions.Finally, there's the none ABI which represent the case of not caring. Unfortunately that ABI isn't widely used as it could be due to us unfortunately making it an opt-out action originally to not have new APIs go into the stable ABI versus opt-in like it should have been. рџЉThe abi3 tag is for the stable ABI. Suffice it to say that Python 3 is better for a reason.

There's whether the wheel contains a fat binary for 32-bit, 64-bit, Intel, or either CPU architectures.And then there's the OS version. There's 32- versus 64-bit. There's x86 or PowerPC CPU architectures. MacOSFor macOS, it's rather extensive due to the history of the OS. WindowsIn other words the backwards-compatibility obsession that Windows has means you only have to care about whether you're running a 32- or 64-bit CPU.

LinuxThe hardest OS to support is definitely Linux. And this doesn't talk about shifts in macOS details which can shift what a wheel supports.Luckily it isn't a big deal to support multiple macOS versions with a single wheel thanks to compressed tag sets (which will be discussed later in this post). This means that what version of macOS that a Python installation might support can be rather long. Same goes for architecture.

The manylinux1 spec is in PEP 513 and the manylinux2010 spec is in PEP 571. (The spec supports specifying 32-bit or 64-bit x86 support.)Currently there's two versions of manylinux. The idea is that if you can build with whatever old glibc version that the oldest supported CentOS has then any newer glibc will also work and thus work for your Linux distribution because there are very few Linux distributions with support lifetimes as long as CentOS. What this defines is a baseline Linux OS built on top of the oldest supported CentOS version available along with what libraries every Linux distribution would be reasonably expected to have. There's also the simple fact that Linux as an operating system is more of a concept than concrete thing that one can easily specify as a baseline build target for a wheel.And so some very smart people came up with the manylinux concept. This varies from updating packages aggressively and independently of other packages, as well as simply supporting different packages period.

On Pip Wheel For X86 How To Handle The

There is an active discussion going on about how to handle the future of the manylinux spec in terms of whether there should be a perennial manylinux definition or if tagging by year should continue (this stems from the fact it took literally years to get the manylinux2010 spec finished and supported by the appropriate tools).

On Mac Pip Install Wheel For X86