vibe coded impl

Author: rickeylev

plan.md

@@ -0,0 +1,42 @@
+# Plan for adding uv.lock support to pip.parse
+
+## Part 1: Analyze and Plan (Done)
+- Analyzed `python/extensions/pip.bzl`, `python/private/pypi/hub_builder.bzl`, `python/private/pypi/uv_lock.bzl`.
+- Confirmed `uv.lock` structure contains wheel URLs and resolution markers.
+- Identified need to modify `pip_repository_attrs.bzl` and `hub_builder.bzl`.
+
+## Part 2: Basic Implementation
+1.  **Modify `python/private/pypi/pip_repository_attrs.bzl`**:
+    - Add `uv_lock` attribute (label, allow_single_file=True).
+    - Add `_toml2json` attribute (label, default pointing to a tool). Note: Need to verify if `_toml2json` is already available or needs to be added. The `uv_lock.bzl` helper uses `attr._toml2json`, so it must be present on the calling rule/tag.
+
+2.  **Modify `python/private/pypi/hub_builder.bzl`**:
+    - In `_pip_parse`:
+        - Check if `pip_attr.uv_lock` is set.
+        - If set, call `convert_uv_lock_to_json`.
+        - Parse the JSON result.
+        - Iterate over packages in the JSON.
+        - Group packages by name.
+        - For this step, select the highest version for each package name.
+        - Select the first wheel URL for that version.
+        - Create `whl_library` repositories for these wheels.
+        - Ensure these `whl_library` calls are integrated into `self._whl_libraries`.
+
+3.  **Verify**:
+    - Run `bazel run //tests/uv_pypi:bin`.
+
+## Part 3: Advanced Implementation (Multiple Versions)
+1.  **Handle Resolution Markers**:
+    - Parse `resolution-markers` from `uv.lock` packages.
+    - Instead of picking one version, keep all versions that have distinct resolution markers.
+
+2.  **Use `wheel_tags_settings`**:
+    - In `hub_builder.bzl`, when constructing the hub repository content (via `hub_repository`), we need to pass information about these multiple versions.
+    - The `hub_repository` rule (or the macros creating it) needs to generate `define_wheel_tag_settings` in the `BUILD.bazel` of the hub.
+    - Generate `alias` targets using `select()` based on the defined settings.
+
+3.  **Refactor Hub Generation**:
+    - Update `hub_repository.bzl` (or the template it uses) to support this new "multi-version via select" pattern, if it doesn't already. The prompt suggests modifying the "hub build file for a package".
+
+4.  **Verify**:
+    - Run the test again. It should correctly pick `absl-py` 2.3.1 or 2.4.0 based on the environment/platform.

python/private/pypi/extension.bzl

@@ -272,6 +272,7 @@ You cannot use both the additive_build_content and additive_build_content_file a
     exposed_packages = {}
     extra_aliases = {}
     whl_libraries = {}
+    uv_selectors = {}
     for hub in pip_hub_map.values():
         out = hub.build()
 
@@ -285,6 +286,7 @@ You cannot use both the additive_build_content and additive_build_content_file a
         extra_aliases[hub.name] = out.extra_aliases
         hub_group_map[hub.name] = out.group_map
         hub_whl_map[hub.name] = out.whl_map
+        uv_selectors[hub.name] = out.uv_selectors
 
     return struct(
         config = config,
@@ -294,6 +296,7 @@ You cannot use both the additive_build_content and additive_build_content_file a
         hub_whl_map = hub_whl_map,
         whl_libraries = whl_libraries,
         whl_mods = whl_mods,
+        uv_selectors = uv_selectors,
         platform_config_settings = {
             hub_name: {
                 platform_name: sorted([str(Label(cv)) for cv in p.config_settings])
@@ -386,6 +389,7 @@ def _pip_impl(module_ctx):
                 key: whl_config_settings_to_json(values)
                 for key, values in whl_map.items()
             },
+            uv_selectors = mods.uv_selectors.get(hub_name, {}),
             packages = mods.exposed_packages.get(hub_name, []),
             platform_config_settings = mods.platform_config_settings.get(hub_name, {}),
             groups = mods.hub_group_map.get(hub_name),

python/private/pypi/hub_builder.bzl

@@ -11,8 +11,10 @@ load(":evaluate_markers.bzl", "evaluate_markers_py", evaluate_markers_star = "ev
 load(":parse_requirements.bzl", "parse_requirements")
 load(":pep508_env.bzl", "env")
 load(":pep508_evaluate.bzl", "evaluate")
+load(":pypi_repo_utils.bzl", "pypi_repo_utils")
 load(":python_tag.bzl", "python_tag")
 load(":requirements_files_by_platform.bzl", "requirements_files_by_platform")
+load(":uv_lock.bzl", "convert_uv_lock_to_json")
 load(":whl_config_setting.bzl", "whl_config_setting")
 load(":whl_repo_name.bzl", "pypi_repo_name", "whl_repo_name")
 
@@ -65,6 +67,7 @@ def hub_builder(
         _group_map = {},  # modified by _add_group_map
         _whl_libraries = {},  # modified by _add_whl_library
         _whl_map = {},  # modified by _add_whl_library
+        _uv_selectors = {}, # modified by _process_uv_lock
         # internal
         _platforms = {},
         _group_name_by_whl = {},
@@ -111,6 +114,7 @@ def _build(self):
         },
         exposed_packages = sorted(self._exposed_packages),
         whl_libraries = self._whl_libraries,
+        uv_selectors = self._uv_selectors,
     )
 
 def _pip_parse(self, module_ctx, pip_attr):
@@ -157,6 +161,11 @@ def _pip_parse(self, module_ctx, pip_attr):
         # to `{os}_{arch}`.
         target_platforms = pip_attr.target_platforms or ([] if default_cross_setup else ["{os}_{arch}"]),
     )
+
+    if pip_attr.uv_lock:
+        _process_uv_lock(self, module_ctx, pip_attr)
+        return
+
     _add_group_map(self, pip_attr.experimental_requirement_cycles)
     _add_extra_aliases(self, pip_attr.extra_hub_aliases)
     _create_whl_repos(
@@ -167,6 +176,97 @@ def _pip_parse(self, module_ctx, pip_attr):
         enable_pipstar_extract = self._config.enable_pipstar_extract or self._get_index_urls.get(pip_attr.python_version),
     )
 
+def _process_uv_lock(self, module_ctx, pip_attr):
+    interpreter = _detect_interpreter(self, pip_attr)
+
+    real_interpreter = pypi_repo_utils.resolve_python_interpreter(
+        module_ctx,
+        python_interpreter = interpreter.path,
+        python_interpreter_target = interpreter.target,
+    )
+
+    json_str = convert_uv_lock_to_json(module_ctx, pip_attr, self._logger, python_interpreter = real_interpreter)
+    lock_data = json.decode(json_str)
+
+    packages = lock_data.get("package", [])
+    packages_by_name = {}
+    for pkg in packages:
+        name = normalize_name(pkg["name"])
+        packages_by_name.setdefault(name, []).append(pkg)
+
+    # Common args logic
+    common_args = _common_args(
+        self,
+        module_ctx,
+        pip_attr = pip_attr,
+        enable_pipstar = False, # TODO: Support pipstar
+    )
+
+    for name, pkgs in packages_by_name.items():
+        package_settings = []
+        for pkg in pkgs:
+            version = pkg["version"]
+            wheels = pkg.get("wheels", [])
+            if not wheels:
+                continue
+
+            # Use first wheel
+            wheel = wheels[0]
+            wheel_url = wheel["url"]
+            wheel_hash = wheel.get("hash")
+
+            # Create repo
+            src = struct(
+                requirement_line = "{}=={}".format(name, version),
+                filename = wheel_url.split("/")[-1],
+                url = wheel_url,
+                sha256 = wheel_hash.replace("sha256:", "") if wheel_hash else None,
+                distribution = name,
+                target_platforms = [],
+                extra_pip_args = [],
+                is_multiple_versions = False,
+            )
+
+            whl_library_args = dict(common_args)
+            # Add extra args if needed
+            whl_library_args.update(dict(
+                dep_template = "@{}//{{name}}:{{target}}".format(self.name),
+            ))
+
+            repo = _whl_repo(
+                src = src,
+                whl_library_args = whl_library_args,
+                download_only = pip_attr.download_only,
+                netrc = self._config.netrc or pip_attr.netrc,
+                auth_patterns = self._config.auth_patterns or pip_attr.auth_patterns,
+                python_version = _major_minor_version(pip_attr.python_version),
+                is_multiple_versions = False,
+                use_downloader = True,
+                interpreter = interpreter,
+                enable_pipstar = False,
+                enable_pipstar_extract = False,
+            )
+
+            repo_name = repo.repo_name
+            if repo_name not in self._whl_libraries:
+                self._whl_libraries[repo_name] = repo.args
+
+            markers = pkg.get("resolution-markers", [])
+            if not markers:
+                package_settings.append((repo_name, None))
+            else:
+                for m in markers:
+                    package_settings.append((repo_name, m))
+
+        if package_settings:
+            self._uv_selectors[name] = json.encode(package_settings)
+
+    # We also need to add exposed packages for the hub
+    _add_exposed_packages(self, {
+        name: None
+        for name in packages_by_name.keys()
+    })
+
 ### end of PUBLIC methods
 ### setters for build outputs
 

python/private/pypi/hub_repository.bzl

@@ -45,6 +45,68 @@ def _impl(rctx):
     # `requirement`, et al. macros.
     macro_tmpl = "@@{name}//{{}}:{{}}".format(name = rctx.attr.name)
 
+    if rctx.attr.uv_selectors:
+        for pkg_name, selectors_json in rctx.attr.uv_selectors.items():
+            settings = json.decode(selectors_json)
+            # settings is list of [repo, marker]
+            
+            select_dict = {}
+            for i, entry in enumerate(settings):
+                repo = entry[0]
+                marker = entry[1]
+                if marker:
+                    select_dict[":pick_{}".format(i)] = "@" + repo
+                else:
+                    select_dict["//conditions:default"] = "@" + repo
+
+            # We create aliases for pkg, whl, data, dist_info
+            # repo points to the whl_library which has these targets.
+            # So actual should be repo + "//:pkg" etc.
+            
+            def make_select(suffix):
+                d = {}
+                for k, v in select_dict.items():
+                    d[k] = v + suffix
+                return render.dict(d)
+
+            content = """
+load("@rules_python//python/private/pypi:uv_lock_targets.bzl", "define_wheel_tag_settings")
+
+package(default_visibility = ["//visibility:public"])
+
+define_wheel_tag_settings({settings})
+
+alias(
+    name = "{pkg_name}",
+    actual = ":pkg",
+)
+alias(
+    name = "pkg",
+    actual = select({select_pkg}),
+)
+alias(
+    name = "whl",
+    actual = select({select_whl}),
+)
+alias(
+    name = "data",
+    actual = select({select_data}),
+)
+alias(
+    name = "dist_info",
+    actual = select({select_dist_info}),
+)
+""".format(
+                pkg_name = pkg_name,
+                settings = render.list(settings),
+                select_pkg = make_select("//:pkg"),
+                select_whl = make_select("//:whl"),
+                select_data = make_select("//:data"),
+                select_dist_info = make_select("//:dist_info"),
+            )
+            rctx.file("{}/BUILD.bazel".format(pkg_name), content)
+
+
     rctx.file("BUILD.bazel", _BUILD_FILE_CONTENTS)
     rctx.template(
         "config.bzl",
@@ -99,6 +161,10 @@ The wheel map where values are json.encoded strings of the whl_map constructed
 in the pip.parse tag class.
 """,
         ),
+        "uv_selectors": attr.string_dict(
+            mandatory = False,
+            doc = "Map of package name to JSON list of (repo, marker) for uv.lock support",
+        ),
         "_config_template": attr.label(
             default = ":config.bzl.tmpl",
         ),

python/private/pypi/pip_repository_attrs.bzl

@@ -70,4 +70,20 @@ True will become default in a subsequent release.
     ),
 }
 
+UV_ATTRS = {
+    "uv_lock": attr.label(
+        allow_single_file = True,
+        doc = """\
+The uv.lock file to use for resolving dependencies.
+""",
+    ),
+    "_toml2json": attr.label(
+        default = Label("//tools/toml2json:toml2json.py"),
+        allow_single_file = True,
+        cfg = "exec",
+        executable = True,
+    ),
+}
+
+ATTRS.update(**UV_ATTRS)
 ATTRS.update(**COMMON_ATTRS)

python/private/pypi/uv_lock.bzl

@@ -1,6 +1,6 @@
 load("//python/private/pypi:pypi_repo_utils.bzl", "pypi_repo_utils")
 
-def convert_uv_lock_to_json(mrctx, attr, logger):
+def convert_uv_lock_to_json(mrctx, attr, logger, python_interpreter = None):
     """Converts a uv.lock file to json.
 
     Args:
@@ -9,16 +9,25 @@ def convert_uv_lock_to_json(mrctx, attr, logger):
             `_python_interpreter_target` attribute of the interpreter
             to use.
         logger: a logger object to use
+        python_interpreter: (optional) The resolved python interpreter object.
 
     Returns:
         The command output, which is a json string.
     """
-    python_interpreter = pypi_repo_utils.resolve_python_interpreter(
-        mrctx,
-        python_interpreter_target = attr._python_interpreter_target,
-    )
+    if not python_interpreter:
+        python_interpreter_target = getattr(attr, "_python_interpreter_target", None)
+        if not python_interpreter_target:
+            python_interpreter_target = getattr(attr, "python_interpreter_target", None)
+
+        python_interpreter = pypi_repo_utils.resolve_python_interpreter(
+            mrctx,
+            python_interpreter_target = python_interpreter_target,
+        )
     toml2json = mrctx.path(attr._toml2json)
-    src_path = mrctx.path(attr.srcs[0])
+    if hasattr(attr, "uv_lock") and attr.uv_lock:
+        src_path = mrctx.path(attr.uv_lock)
+    else:
+        src_path = mrctx.path(attr.srcs[0])
 
     stdout = pypi_repo_utils.execute_checked_stdout(
         mrctx,

python/private/pypi/uv_lock_targets.bzl

@@ -41,3 +41,29 @@ def define_targets(name, selectors):
         name = name,
         actual = select(select_map),
     )
+
+def define_wheel_tag_settings(settings):
+    """Defines the wheel tag settings and config settings.
+
+    Args:
+        settings: list of (repo_name, marker_expression).
+    """
+    for i, (repo, marker) in enumerate(settings):
+        # name for the marker rule
+        marker_name = "marker_{}".format(i)
+        # name for the config setting (used in select keys)
+        config_name = "pick_{}".format(i)
+
+        if marker:
+            env_marker_setting(
+                name = marker_name,
+                expression = marker,
+            )
+            native.config_setting(
+                 name = config_name,
+                 flag_values = { ":" + marker_name : "TRUE" }
+            )
+        else:
+            # If no marker, we can't create a config setting that matches "everything" easily 
+            # without a flag. But maybe we don't need to if we use //conditions:default in the select.
+            pass

python/private/pypi/wheel_tags_setting.bzl

@@ -73,7 +73,7 @@ def _wheel_tags_setting_impl(ctx):
     if platform_tag == "any":
         platform_is_compatible = True
     else:
-        libc = "musl" if musl in platform_tag else "glibc"
+        libc = "musl" if "musl" in platform_tag else "glibc"
         if "linux" in platform_tag:
             os = "linux"
         else: