use kwargs

Author: aignas

python/uv/private/lock.bzl

@@ -374,14 +374,13 @@ def lock(
         generate_hashes = True,
         python_version = None,
         strip_extras = False,
-        target_compatible_with = None,
-        tags = ["manual"],
-        visibility = None):
+        **kwargs):
     """Pin the requirements based on the src files.
 
     This macro creates the following targets:
     - `name`: the target that creates the requirements.txt file in a build
-      action.
+      action. This target will have `no-cache` and `requires-network` added
+      to its tags.
     - `name.run`: a runnable target that can be used to pass extra parameters
       to the same command that would be run in the `name` action. This will
       update the source copy of the requirements file. You can customize the
@@ -394,6 +393,10 @@ def lock(
       args via command line, but you can use RBE to generate requirements
       (offload execution and run for different platforms)
 
+    :::{note}
+    All of the targets have `manual` tags as locking results cannot be cached.
+    :::
+
     Args:
         name: {type}`str` The prefix of all targets created by this macro.
         srcs: {type}`list[Label]` The sources that will be used. Add all of the
@@ -416,11 +419,7 @@ def lock(
         python_version: {type}`str | None` the python_version to transition to
             when locking the requirements. Defaults to the default python version
             configured by the {obj}`python` module extension.
-        target_compatible_with: The `target_compatible_with` for the locking action.
-        tags: The common tags for all of the targets. This defaults to [`manual`].
-            Note, that the locking target also adds `requires-network` and
-            `no-cache` due to the nature of how `uv` works.
-        visibility: {attr}`list[str]` The visibility of the documented targets.
+        **kwargs: common kwargs passed to rules.
     """
     update_target = "{}.update".format(name)
     locker_target = "{}.run".format(name)
@@ -429,10 +428,10 @@ def lock(
     # output file location in order to make `uv` not change the requirements if
     # we are just running the command.
     maybe_out = _maybe_file(out)
-    if target_compatible_with == None and not BZLMOD_ENABLED:
-        target_compatible_with = ["@platforms//:incompatible"]
-    elif target_compatible_with == None:
-        target_compatible_with = []
+
+    tags = ["manual"] + kwargs.pop("tags", [])
+    if not BZLMOD_ENABLED:
+        kwargs["target_compatible_with"] = ["@platforms//:incompatible"]
 
     # FIXME @aignas 2025-03-17: should we have one more target that transitions
     # the python_version to ensure that if somebody calls `bazel build
@@ -448,14 +447,13 @@ def lock(
         python_version = python_version,
         srcs = srcs,
         strip_extras = strip_extras,
-        target_compatible_with = target_compatible_with,
         update_target = update_target,
         output = out,
         tags = [
             "no-cache",
             "requires-network",
         ] + tags,
-        visibility = visibility,
+        **kwargs
     )
 
     # A target for updating the in-tree version directly by skipping the in-action
@@ -469,7 +467,7 @@ def lock(
             "//conditions:default": False,
         }),
         tags = tags,
-        visibility = visibility,
+        **kwargs
     )
 
     # FIXME @aignas 2025-03-20: is it possible to extend `py_binary` so that the
@@ -489,5 +487,5 @@ def lock(
         srcs = [template_target],
         data = [name] + ([maybe_out] if maybe_out else []),
         tags = tags,
-        visibility = visibility,
+        **kwargs
     )