more cleanup

Author: aignas

python/private/pypi/BUILD.bazel

@@ -263,11 +263,6 @@ bzl_library(
     ],
 )
 
-bzl_library(
-    name = "pep508_platform_bzl",
-    srcs = ["pep508_platform.bzl"],
-)
-
 bzl_library(
     name = "pep508_requirement_bzl",
     srcs = ["pep508_requirement.bzl"],
@@ -341,6 +336,9 @@ bzl_library(
 bzl_library(
     name = "python_tag_bzl",
     srcs = ["python_tag.bzl"],
+    deps = [
+        "//python/private:version_bzl",
+    ],
 )
 
 bzl_library(

python/private/pypi/extension.bzl

@@ -78,22 +78,17 @@ def _platforms(*, python_version, minor_mapping, config):
     )
 
     for platform, values in config.platforms.items():
-        implementation = python_tag(values.env["implementation_name"])
-
-        # TODO @aignas 2025-07-07: move the abi construction somewhere else
-        abi = "{impl}{0}{1}.{2}".format(
-            impl = implementation,
-            *python_version.release
-        )
-        key = "{}_{}".format(abi, platform)
-
-        env_ = env(struct(
-            abi = abi,
-            os = values.os_name,
-            arch = values.arch_name,
-        )) | values.env
-        platforms[key] = struct(
-            env = env_,
+        # TODO @aignas 2025-07-07: this is probably doing the parsing of the version too
+        # many times.
+        pytag = python_tag(values.env["implementation_name"], python_version.string)
+
+        platforms["{}.{}_{}".format(pytag, python_version.release[2], platform)] = struct(
+            env = env(
+                env = values.env,
+                os = values.os_name,
+                arch = values.arch_name,
+                python_version = python_version.string,
+            ),
             want_abis = [
                 v.format(
                     major = python_version.release[0],

python/private/pypi/pep508_env.bzl

@@ -15,6 +15,8 @@
 """This module is for implementing PEP508 environment definition.
 """
 
+load("//python/private:version.bzl", "version")
+
 _DEFAULT = "//conditions:default"
 
 # See https://stackoverflow.com/a/45125525
@@ -144,37 +146,38 @@ def _get_from_map(m, key):
     else:
         return m[key]
 
-def env(target_platform, *, extra = None):
+def env(*, env = None, os, arch, python_version = "", extra = None):
     """Return an env target platform
 
     NOTE: This is for use during the loading phase. For the analysis phase,
     `env_marker_setting()` constructs the env dict.
 
     Args:
-        target_platform: {type}`str` the target platform identifier, e.g.
-            `cp33_linux_aarch64`
+        env: {type}`str` the environment.
+        os: {type}`str` the OS name.
+        arch: {type}`str` the CPU name.
+        python_version: {type}`str` the full python version.
         extra: {type}`str` the extra value to be added into the env.
 
     Returns:
         A dict that can be used as `env` in the marker evaluation.
     """
-    env = create_env()
+    env = env or {}
+    env = env | create_env()
     if extra != None:
         env["extra"] = extra
 
-    if target_platform.abi:
-        # TODO @aignas 2025-07-07: do not parse the version like this here
-        minor_version, _, micro_version = target_platform.abi[3:].partition(".")
-        micro_version = micro_version or "0"
+    if python_version:
+        v = version.parse(python_version)
         env = env | {
-            "implementation_version": "3.{}.{}".format(minor_version, micro_version),
-            "python_full_version": "3.{}.{}".format(minor_version, micro_version),
-            "python_version": "3.{}".format(minor_version),
+            "implementation_version": "{}.{}.{}".format(v.release[0], v.release[1], v.release[2]),
+            "python_full_version": "{}.{}.{}".format(v.release[0], v.release[1], v.release[2]),
+            "python_version": "{}.{}".format(v.release[0], v.release[1]),
         }
 
-    if target_platform.os and target_platform.arch:
-        os = "@platforms//os:{}".format(target_platform.os)
-        arch = "@platforms//cpu:{}".format(target_platform.arch)
+    if os and arch:
+        os = "@platforms//os:{}".format(os)
+        arch = "@platforms//cpu:{}".format(arch)
         env = env | {
             "os_name": _get_from_map(os_name_select_map, os),
             "platform_machine": _get_from_map(platform_machine_select_map, arch),

python/private/pypi/pep508_platform.bzl

@@ -1,5 +1,7 @@
 "A simple utility function to get the python_tag from the implementation name"
 
+load("//python/private:version.bzl", "version")
+
 # Taken from
 # https://packaging.python.org/en/latest/specifications/platform-compatibility-tags/#python-tag
 _PY_TAGS = {
@@ -8,16 +10,32 @@ _PY_TAGS = {
     "ironpython": "ip",
     "jython": "jy",
     "pypy": "pp",
+    "python": "py",
 }
 PY_TAG_GENERIC = "py"
 
-def python_tag(implementation_name):
+def python_tag(implementation_name, python_version = ""):
     """Get the python_tag from the implementation_name.
 
     Args:
         implementation_name: {type}`str` the implementation name, e.g. "cpython"
+        python_version: {type}`str` a version who can be parsed using PEP440 compliant
+            parser.
 
     Returns:
-        A {type}`str` that represents the python_tag.
+        A {type}`str` that represents the python_tag with a version if the
+            python_version is given.
     """
-    return _PY_TAGS.get(implementation_name, implementation_name)
+    if python_version:
+        v = version.parse(python_version, strict = True)
+        suffix = "{}{}".format(
+            v.release[0],
+            v.release[1] if len(v.release) > 1 else "",
+        )
+    else:
+        suffix = ""
+
+    return "{}{}".format(
+        _PY_TAGS.get(implementation_name, implementation_name),
+        suffix,
+    )

python/private/pypi/python_tag.bzl

@@ -17,7 +17,6 @@
 load("@rules_testing//lib:test_suite.bzl", "test_suite")
 load("//python/private/pypi:parse_requirements.bzl", "parse_requirements", "select_requirement")  # buildifier: disable=bzl-visibility
 load("//python/private/pypi:pep508_env.bzl", pep508_env = "env")  # buildifier: disable=bzl-visibility
-load("//python/private/pypi:pep508_platform.bzl", "platform_from_str")  # buildifier: disable=bzl-visibility
 
 def _mock_ctx():
     testdata = {
@@ -527,12 +526,20 @@ def _test_overlapping_shas_with_index_results(env):
         platforms = {
             "cp39_linux_x86_64": struct(
                 platform_tags = ["any"],
-                env = pep508_env(platform_from_str("cp39_linux_x86_64", "")),
+                env = pep508_env(
+                    python_version = "3.9.0",
+                    os = "linux",
+                    arch = "x86_64",
+                ),
                 want_abis = ["none"],
             ),
             "cp39_osx_x86_64": struct(
                 platform_tags = ["macosx_*"],
-                env = pep508_env(platform_from_str("cp39_linux_x86_64", "")),
+                env = pep508_env(
+                    python_version = "3.9.0",
+                    os = "osx",
+                    arch = "x86_64",
+                ),
                 want_abis = ["none"],
             ),
         },

tests/pypi/parse_requirements/parse_requirements_tests.bzl

@@ -16,7 +16,6 @@
 load("@rules_testing//lib:test_suite.bzl", "test_suite")
 load("//python/private/pypi:pep508_env.bzl", pep508_env = "env")  # buildifier: disable=bzl-visibility
 load("//python/private/pypi:pep508_evaluate.bzl", "evaluate", "tokenize")  # buildifier: disable=bzl-visibility
-load("//python/private/pypi:pep508_platform.bzl", "platform_from_str")  # buildifier: disable=bzl-visibility
 
 _tests = []
 
@@ -244,26 +243,29 @@ _tests.append(_evaluate_partial_only_extra)
 
 def _evaluate_with_aliases(env):
     # When
-    for target_platform, tests in {
+    for (os, cpu), tests in {
         # buildifier: @unsorted-dict-items
-        "osx_aarch64": {
+        ("osx", "aarch64"): {
             "platform_system == 'Darwin' and platform_machine == 'arm64'": True,
             "platform_system == 'Darwin' and platform_machine == 'aarch64'": True,
             "platform_system == 'Darwin' and platform_machine == 'amd64'": False,
         },
-        "osx_x86_64": {
+        ("osx", "x86_64"): {
             "platform_system == 'Darwin' and platform_machine == 'amd64'": True,
             "platform_system == 'Darwin' and platform_machine == 'x86_64'": True,
         },
-        "osx_x86_32": {
+        ("osx", "x86_32"): {
             "platform_system == 'Darwin' and platform_machine == 'i386'": True,
             "platform_system == 'Darwin' and platform_machine == 'i686'": True,
             "platform_system == 'Darwin' and platform_machine == 'x86_32'": True,
             "platform_system == 'Darwin' and platform_machine == 'x86_64'": False,
         },
     }.items():  # buildifier: @unsorted-dict-items
         for input, want in tests.items():
-            _check_evaluate(env, input, want, pep508_env(platform_from_str(target_platform, "")))
+            _check_evaluate(env, input, want, pep508_env(
+                os = os,
+                arch = cpu,
+            ))
 
 _tests.append(_evaluate_with_aliases)