From 07fedaccb509fdb76738c350be009a035f3079fe Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Thu, 13 Feb 2025 22:14:00 +0900 Subject: [PATCH 01/65] feat(pep508): initial parsing support --- python/private/pypi/pep508.bzl | 23 ++ python/private/pypi/pep508_env.bzl | 75 ++++ python/private/pypi/pep508_evaluate.bzl | 483 ++++++++++++++++++++++++ python/private/semver.bzl | 55 ++- tests/pypi/pep508/BUILD.bazel | 5 + tests/pypi/pep508/evaluate_tests.bzl | 241 ++++++++++++ tests/semver/semver_test.bzl | 18 + 7 files changed, 891 insertions(+), 9 deletions(-) create mode 100644 python/private/pypi/pep508.bzl create mode 100644 python/private/pypi/pep508_env.bzl create mode 100644 python/private/pypi/pep508_evaluate.bzl create mode 100644 tests/pypi/pep508/BUILD.bazel create mode 100644 tests/pypi/pep508/evaluate_tests.bzl diff --git a/python/private/pypi/pep508.bzl b/python/private/pypi/pep508.bzl new file mode 100644 index 0000000000..92cf61bb74 --- /dev/null +++ b/python/private/pypi/pep508.bzl @@ -0,0 +1,23 @@ +# Copyright 2024 The Bazel Authors. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""This module is for implementing PEP508 in starlark as FeatureFlagInfo +""" + +load(":pep508_env.bzl", _env = "env") +load(":pep508_evaluate.bzl", _evaluate = "evaluate", _to_string = "to_string") + +to_string = _to_string +evaluate = _evaluate +env = _env diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl new file mode 100644 index 0000000000..ec045737cc --- /dev/null +++ b/python/private/pypi/pep508_env.bzl @@ -0,0 +1,75 @@ +# Copyright 2024 The Bazel Authors. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""This module is for implementing PEP508 environment definition. +""" + +_platform_machine_values = { + "aarch64": "arm64", + "ppc": "ppc64le", + "s390x": "s390x", + "x86_32": "i386", + "x86_64": "x86_64", +} +_platform_system_values = { + "linux": "Linux", + "osx": "Darwin", + "windows": "Windows", +} +_sys_platform_values = { + "linux": "posix", + "osx": "darwin", + "windows": "win32", +} +_os_name_values = { + "linux": "posix", + "osx": "posix", + "windows": "nt", +} + +def env(target_platform): + """Return an env target platform + + Args: + target_platform: {type}`str` the target platform identifier, e.g. + `cp33_linux_aarch64` + + Returns: + A dict that can be used as `env` in the marker evaluation. + """ + abi, _, tail = target_platform.partition("_") + + # TODO @aignas 2024-12-26: wire up the usage of the micro version + minor, _, micro = abi[3:].partition(".") + micro = micro or "0" + os, _, cpu = tail.partition("_") + + # TODO @aignas 2025-02-13: consider moving this into config settings. + + # This is split by topic + return { + "os_name": _os_name_values.get(os, ""), + "platform_machine": "aarch64" if (os, cpu) == ("linux", "aarch64") else _platform_machine_values.get(cpu, ""), + "platform_system": _platform_system_values.get(os, ""), + "sys_platform": _sys_platform_values.get(os, ""), + } | { + "implementation_name": "cpython", + "platform_python_implementation": "CPython", + "platform_release": "", + "platform_version": "", + } | { + "implementation_version": "3.{}.{}".format(minor, micro), + "python_full_version": "3.{}.{}".format(minor, micro), + "python_version": "3.{}".format(minor), + } diff --git a/python/private/pypi/pep508_evaluate.bzl b/python/private/pypi/pep508_evaluate.bzl new file mode 100644 index 0000000000..1226ab6532 --- /dev/null +++ b/python/private/pypi/pep508_evaluate.bzl @@ -0,0 +1,483 @@ +# Copyright 2024 The Bazel Authors. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""This module is for implementing PEP508 in starlark as FeatureFlagInfo +""" + +load("//python/private:enum.bzl", "enum") +load("//python/private:semver.bzl", "semver") + +# The expression parsing and resolution for the PEP508 is below +# + +# Taken from +# https://peps.python.org/pep-0508/#grammar +# +# version_cmp = wsp* '<' | '<=' | '!=' | '==' | '>=' | '>' | '~=' | '===' +_VERSION_CMP = sorted( + [ + i.strip(" '") + for i in "'<' | '<=' | '!=' | '==' | '>=' | '>' | '~=' | '==='".split(" | ") + ], + key = lambda x: (-len(x), x), +) + +_STATE = enum( + STRING = "string", + VAR = "var", + OP = "op", + NONE = "none", +) +_BRACKETS = "()" +_OPCHARS = "<>!=~" +_QUOTES = "'\"" +_WSP = " \t" +_NON_VERSION_VAR_NAMES = [ + "implementation_name", + "os_name", + "platform_machine", + "platform_python_implementation", + "platform_release", + "platform_system", + "sys_platform", + "extra", +] +_AND = "and" +_OR = "or" +_NOT = "not" + +def tokenize(marker): + """Tokenize the input string. + + The output will have double-quoted values (i.e. the quoting will be normalized) and all of the whitespace will be trimmed. + + Args: + marker: {type}`str` The input to tokenize. + + Returns: + The {type}`str` that is the list of recognized tokens that should be parsed. + """ + if not marker: + return [] + + tokens = [] + token = "" + state = _STATE.NONE + char = "" + + # Due to the `continue` in the loop, we will be processing chars at a slower pace + for _ in range(2 * len(marker)): + if token and (state == _STATE.NONE or not marker): + if tokens and token == "in" and tokens[-1] == _NOT: + tokens[-1] += " " + token + else: + tokens.append(token) + token = "" + + if not marker: + return tokens + + char = marker[0] + if char in _BRACKETS: + state = _STATE.NONE + token = char + elif state == _STATE.STRING and char in _QUOTES: + state = _STATE.NONE + token = '"{}"'.format(token) + elif ( + (state == _STATE.VAR and not char.isalnum() and char != "_") or + (state == _STATE.OP and char not in _OPCHARS) + ): + state = _STATE.NONE + continue # Skip consuming the char below + elif state == _STATE.NONE: + # Transition from _STATE.NONE to something or stay in NONE + if char in _QUOTES: + state = _STATE.STRING + elif char.isalnum(): + state = _STATE.VAR + token += char + elif char in _OPCHARS: + state = _STATE.OP + token += char + elif char in _WSP: + state = _STATE.NONE + else: + fail("BUG: Cannot parse '{}' in {}".format(char, state)) + else: + token += char + + # Consume the char + marker = marker[1:] + + return fail("BUG: failed to process the marker in allocated cycles: {}".format(marker)) + +def evaluate(marker, *, env, strict = True, **kwargs): + """Evaluate the marker against a given env. + + Args: + marker: {type}`str`: The string marker to evaluate. + env: {type}`dict`: The environment to evaluate the marker against. + strict: {type}`bool`: A setting to not fail on missing values in the env. + **kwargs: Extra kwargs to be passed to the expression evaluator. + + Returns: + The {type}`bool` If the marker is compatible with the given env. + """ + tokens = tokenize(marker) + + ast = _new_expr(**kwargs) + for _ in range(len(tokens) * 2): + if not tokens: + break + + tokens = ast.parse(env = env, tokens = tokens, strict = strict) + + if not tokens: + return ast.value() + + fail("Could not evaluate: {}".format(marker)) + +_STRING_REPLACEMENTS = { + "!=": "neq", + "(": "_", + ")": "_", + "<": "lt", + "<=": "lteq", + "==": "eq", + "===": "eeq", + ">": "gt", + ">=": "gteq", + "not in": "not_in", + "~==": "cmp", +} + +def to_string(marker): + return "_".join([ + _STRING_REPLACEMENTS.get(t, t) + for t in tokenize(marker) + ]).replace("\"", "") + +def _and_fn(x, y): + """Our custom `and` evaluation function. + + Allow partial evaluation if one of the values is a string, return the + string value because that means that `marker_expr` was set to + `strict = False` and we are only evaluating what we can. + """ + if not (x and y): + return False + + x_is_str = type(x) == type("") + y_is_str = type(y) == type("") + if x_is_str and y_is_str: + return "{} and {}".format(x, y) + elif x_is_str: + return x + else: + return y + +def _or_fn(x, y): + """Our custom `or` evaluation function. + + Allow partial evaluation if one of the values is a string, return the + string value because that means that `marker_expr` was set to + `strict = False` and we are only evaluating what we can. + """ + x_is_str = type(x) == type("") + y_is_str = type(y) == type("") + + if x_is_str and y_is_str: + return "{} or {}".format(x, y) if x and y else "" + elif x_is_str: + return "" if y else x + elif y_is_str: + return "" if x else y + else: + return x or y + +def _not_fn(x): + """Our custom `not` evaluation function. + + Allow partial evaluation if the value is a string. + """ + if type(x) == type(""): + return "not {}".format(x) + else: + return not x + +def _new_expr( + and_fn = _and_fn, + or_fn = _or_fn, + not_fn = _not_fn): + # buildifier: disable=uninitialized + self = struct( + tree = [], + parse = lambda **kwargs: _parse(self, **kwargs), + value = lambda: _value(self), + # This is a way for us to have a handle to the currently constructed + # expression tree branch. + current = lambda: self._current[0] if self._current else None, + _current = [], + _and = and_fn, + _or = or_fn, + _not = not_fn, + ) + return self + +def _parse(self, *, env, tokens, strict = False): + """The parse function takes the consumed tokens and returns the remaining.""" + token, remaining = tokens[0], tokens[1:] + + if token == "(": + expr = _open_parenthesis(self) + elif token == ")": + expr = _close_parenthesis(self) + elif token == _AND: + expr = _and_expr(self) + elif token == _OR: + expr = _or_expr(self) + elif token == _NOT: + expr = _not_expr(self) + else: + expr = marker_expr(env = env, strict = strict, *tokens[:3]) + remaining = tokens[3:] + + _append(self, expr) + return remaining + +def _value(self): + """Evaluate the expression tree""" + if not self.tree: + # Basic case where no marker should evaluate to True + return True + + for _ in range(len(self.tree)): + if len(self.tree) == 1: + return self.tree[0] + + # Resolve all of the `or` expressions as it is safe to do now since all + # `and` and `not` expressions have been taken care of by now. + if getattr(self.tree[-2], "op", None) == _OR: + current = self.tree.pop() + self.tree[-1] = self.tree[-1].value(current) + else: + break + + fail("BUG: invalid state: {}".format(self.tree)) + +def marker_expr(left, op, right, *, env, strict = True): + """Evaluate a marker expression + + Args: + left: {type}`str` the env identifier or a value quoted in `"`. + op: {type}`str` the operation to carry out. + right: {type}`str` the env identifier or a value quoted in `"`. + strict: {type}`bool` if false, only evaluates the values that are present + in the environment, otherwise returns the original expression. + env: {type}`dict[str, str]` the `env` to substitute `env` identifiers in + the ` ` expression. + + Returns: + {type}`bool` if the expression evaluation result or {type}`str` if the expression + could not be evaluated. + """ + var_name = None + if right not in env and left not in env and not strict: + return "{} {} {}".format(left, op, right) + if left[0] == '"': + var_name = right + right = env[right] + left = left.strip("\"") + else: + var_name = left + left = env[left] + right = right.strip("\"") + + if var_name in _NON_VERSION_VAR_NAMES: + return _env_expr(left, op, right) + elif var_name.endswith("_version"): + return _version_expr(left, op, right) + else: + # Do not fail here, just evaluate the expression to False. + return False + +def _env_expr(left, op, right): + """Evaluate a string comparison expression""" + if op == "==": + return left == right + elif op == "!=": + return left != right + elif op == "in": + return left in right + elif op == "not in": + return left not in right + else: + return fail("TODO: op unsupported: '{}'".format(op)) + +def _version_expr(left, op, right): + """Evaluate a version comparison expression""" + left = semver(left) + right = semver(right) + _left = left.key() + _right = right.key() + if op == "<": + return _left < _right + elif op == ">": + return _left > _right + elif op == "<=": + return _left <= _right + elif op == ">=": + return _left >= _right + elif op == "!=": + return _left != _right + elif op == "==": + # Matching of major, minor, patch only + return _left[:3] == _right[:3] + elif op == "~=": + right_plus = right.upper() + _right_plus = right_plus.key() + return _left >= _right and _left < _right_plus + elif op == "===": + # Strict matching + return _left == _right + elif op in _VERSION_CMP: + fail("TODO: op unsupported: '{}'".format(op)) + else: + return False # Let's just ignore the invalid ops + +# Code to allowing to combine expressions with logical operators + +def _append(self, value): + if value == None: + return + + current = self.current() or self + op = getattr(value, "op", None) + + if op == _NOT: + current.tree.append(value) + elif op in [_AND, _OR]: + value.append(current.tree[-1]) + current.tree[-1] = value + elif not current.tree: + current.tree.append(value) + elif hasattr(current.tree[-1], "append"): + current.tree[-1].append(value) + else: + current.tree._append(value) + +def _open_parenthesis(self): + """Add an extra node into the tree to perform evaluate inside parenthesis.""" + self._current.append(_new_expr( + and_fn = self._and, + or_fn = self._or, + not_fn = self._not, + )) + +def _close_parenthesis(self): + """Backtrack and evaluate the expression within parenthesis.""" + value = self._current.pop().value() + if type(value) == type(""): + return "({})".format(value) + else: + return value + +def _not_expr(self): + """Add an extra node into the tree to perform an 'not' operation.""" + + def _append(value): + """Append a value to the not expression node. + + This codifies `not` precedence over `and` and performs backtracking to + evaluate any `not` statements and forward the value to the first `and` + statement if needed. + """ + + current = self.current() or self + current.tree[-1] = self._not(value) + + for _ in range(len(current.tree)): + if not len(current.tree) > 1: + break + + op = getattr(current.tree[-2], "op", None) + if op == None: + pass + elif op == _NOT: + value = current.tree.pop() + current.tree[-1] = self._not(value) + continue + elif op == _AND: + value = current.tree.pop() + current.tree[-1].append(value) + elif op != _OR: + fail("BUG: '{} not' compound is unsupported".format(current.tree[-1])) + + break + + return struct( + op = _NOT, + append = _append, + ) + +def _and_expr(self): + """Add an extra node into the tree to perform an 'and' operation""" + maybe_value = [None] + + def _append(value): + """Append a value to the and expression node. + + Here we backtrack, but we only evaluate the current `and` statement - + all of the `not` statements will be by now evaluated and `or` + statements need to be evaluated later. + """ + if maybe_value[0] == None: + maybe_value[0] = value + return + + current = self.current() or self + current.tree[-1] = self._and(maybe_value[0], value) + + return struct( + op = _AND, + append = _append, + # private fields that help debugging + _maybe_value = maybe_value, + ) + +def _or_expr(self): + """Add an extra node into the tree to perform an 'or' operation""" + maybe_value = [None] + + def _append(value): + """Append a value to the or expression node. + + Here we just append the extra values to the tree and the `or` + statements will be evaluated in the _value() function. + """ + if maybe_value[0] == None: + maybe_value[0] = value + return + + current = self.current() or self + current.tree.append(value) + + return struct( + op = _OR, + value = lambda x: self._or(maybe_value[0], x), + append = _append, + # private fields that help debugging + _maybe_value = maybe_value, + ) diff --git a/python/private/semver.bzl b/python/private/semver.bzl index 73d6b130ae..cc9ae6ecb6 100644 --- a/python/private/semver.bzl +++ b/python/private/semver.bzl @@ -43,6 +43,49 @@ def _to_dict(self): "pre_release": self.pre_release, } +def _upper(self): + major = self.major + minor = self.minor + patch = self.patch + build = "" + pre_release = "" + version = self.str() + + if patch != None: + minor = minor + 1 + patch = 0 + elif minor != None: + major = major + 1 + minor = 0 + elif minor == None: + major = major + 1 + + return _new( + major = major, + minor = minor, + patch = patch, + build = build, + pre_release = pre_release, + version = "~" + version, + ) + +def _new(*, major, minor, patch, pre_release, build, version = None): + # buildifier: disable=uninitialized + self = struct( + major = int(major), + minor = None if minor == None else int(minor), + # NOTE: this is called `micro` in the Python interpreter versioning scheme + patch = None if patch == None else int(patch), + pre_release = pre_release, + build = build, + # buildifier: disable=uninitialized + key = lambda: _key(self), + str = lambda: version, + to_dict = lambda: _to_dict(self), + upper = lambda: _upper(self), + ) + return self + def semver(version): """Parse the semver version and return the values as a struct. @@ -59,17 +102,11 @@ def semver(version): patch, _, build = tail.partition("+") patch, _, pre_release = patch.partition("-") - # buildifier: disable=uninitialized - self = struct( + return _new( major = int(major), minor = int(minor) if minor.isdigit() else None, - # NOTE: this is called `micro` in the Python interpreter versioning scheme patch = int(patch) if patch.isdigit() else None, - pre_release = pre_release, build = build, - # buildifier: disable=uninitialized - key = lambda: _key(self), - str = lambda: version, - to_dict = lambda: _to_dict(self), + pre_release = pre_release, + version = version, ) - return self diff --git a/tests/pypi/pep508/BUILD.bazel b/tests/pypi/pep508/BUILD.bazel new file mode 100644 index 0000000000..b795db0591 --- /dev/null +++ b/tests/pypi/pep508/BUILD.bazel @@ -0,0 +1,5 @@ +load(":evaluate_tests.bzl", "evaluate_test_suite") + +evaluate_test_suite( + name = "evaluate_tests", +) diff --git a/tests/pypi/pep508/evaluate_tests.bzl b/tests/pypi/pep508/evaluate_tests.bzl new file mode 100644 index 0000000000..18337c40db --- /dev/null +++ b/tests/pypi/pep508/evaluate_tests.bzl @@ -0,0 +1,241 @@ +# Copyright 2024 The Bazel Authors. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Tests for construction of Python version matching config settings.""" + +load("@rules_testing//lib:test_suite.bzl", "test_suite") +load("//python/private/pypi:pep508_evaluate.bzl", "evaluate", "tokenize") # buildifier: disable=bzl-visibility + +_tests = [] + +def _tokenize_tests(env): + for input, want in { + "": [], + "'osx' == os_name": ['"osx"', "==", "os_name"], + "'x' not in os_name": ['"x"', "not in", "os_name"], + "()": ["(", ")"], + "(os_name == 'osx' and not os_name == 'posix') or os_name == \"win\"": [ + "(", + "os_name", + "==", + '"osx"', + "and", + "not", + "os_name", + "==", + '"posix"', + ")", + "or", + "os_name", + "==", + '"win"', + ], + "os_name\t==\t'osx'": ["os_name", "==", '"osx"'], + "os_name == 'osx'": ["os_name", "==", '"osx"'], + "python_version <= \"1.0\"": ["python_version", "<=", '"1.0"'], + "python_version>='1.0.0'": ["python_version", ">=", '"1.0.0"'], + "python_version~='1.0.0'": ["python_version", "~=", '"1.0.0"'], + }.items(): + got = tokenize(input) + env.expect.that_collection(got).contains_exactly(want).in_order() + +_tests.append(_tokenize_tests) + +def _evaluate_non_version_env_tests(env): + for var_name in [ + "implementation_name", + "os_name", + "platform_machine", + "platform_python_implementation", + "platform_release", + "platform_system", + "sys_platform", + "extra", + ]: + # Given + marker_env = {var_name: "osx"} + + # When + for input, want in { + "{} == 'osx'".format(var_name): True, + "{} != 'osx'".format(var_name): False, + "'osx' == {}".format(var_name): True, + "'osx' != {}".format(var_name): False, + "'x' in {}".format(var_name): True, + "'w' not in {}".format(var_name): True, + }.items(): # buildifier: @unsorted-dict-items + got = evaluate( + input, + env = marker_env, + ) + env.expect.that_bool(got).equals(want) + + # Check that the non-strict eval gives us back the input when no + # env is supplied. + got = evaluate( + input, + env = {}, + strict = False, + ) + env.expect.that_bool(got).equals(input.replace("'", '"')) + +_tests.append(_evaluate_non_version_env_tests) + +def _evaluate_version_env_tests(env): + for var_name in [ + "python_version", + "implementation_version", + "platform_version", + "python_full_version", + ]: + # Given + marker_env = {var_name: "3.7.9"} + + # When + for input, want in { + "{} < '3.8'".format(var_name): True, + "{} > '3.7'".format(var_name): True, + "{} >= '3.7.9'".format(var_name): True, + "{} >= '3.7.10'".format(var_name): False, + "{} >= '3.7.8'".format(var_name): True, + "{} <= '3.7.9'".format(var_name): True, + "{} <= '3.7.10'".format(var_name): True, + "{} <= '3.7.8'".format(var_name): False, + "{} == '3.7.9'".format(var_name): True, + "{} != '3.7.9'".format(var_name): False, + "{} ~= '3.7.1'".format(var_name): True, + "{} ~= '3.7.10'".format(var_name): False, + "{} ~= '3.8.0'".format(var_name): False, + "{} === '3.7.9+rc2'".format(var_name): False, + "{} === '3.7.9'".format(var_name): True, + "{} == '3.7.9+rc2'".format(var_name): True, + }.items(): # buildifier: @unsorted-dict-items + got = evaluate( + input, + env = marker_env, + ) + env.expect.that_collection((input, got)).contains_exactly((input, want)) + + # Check that the non-strict eval gives us back the input when no + # env is supplied. + got = evaluate( + input, + env = {}, + strict = False, + ) + env.expect.that_bool(got).equals(input.replace("'", '"')) + +_tests.append(_evaluate_version_env_tests) + +def _logical_expression_tests(env): + for input, want in { + # Basic + "": True, + "(())": True, + "()": True, + + # expr + "os_name == 'fo'": False, + "(os_name == 'fo')": False, + "not (os_name == 'fo')": True, + + # and + "os_name == 'fo' and os_name == 'foo'": False, + + # and not + "os_name == 'fo' and not os_name == 'foo'": False, + + # or + "os_name == 'oo' or os_name == 'foo'": True, + + # or not + "os_name == 'foo' or not os_name == 'foo'": True, + + # multiple or + "os_name == 'oo' or os_name == 'fo' or os_name == 'foo'": True, + "os_name == 'oo' or os_name == 'foo' or os_name == 'fo'": True, + + # multiple and + "os_name == 'foo' and os_name == 'foo' and os_name == 'fo'": False, + + # x or not y and z != (x or not y), but is instead evaluated as x or (not y and z) + "os_name == 'foo' or not os_name == 'fo' and os_name == 'fo'": True, + + # x or y and z != (x or y) and z, but is instead evaluated as x or (y and z) + "os_name == 'foo' or os_name == 'fo' and os_name == 'fo'": True, + "not (os_name == 'foo' or os_name == 'fo' and os_name == 'fo')": False, + + # x or y and z and w != (x or y and z) and w, but is instead evaluated as x or (y and z and w) + "os_name == 'foo' or os_name == 'fo' and os_name == 'fo' and os_name == 'fo'": True, + + # not not True + "not not os_name == 'foo'": True, + "not not not os_name == 'foo'": False, + }.items(): # buildifier: @unsorted-dict-items + got = evaluate( + input, + env = { + "os_name": "foo", + }, + ) + env.expect.that_collection((input, got)).contains_exactly((input, want)) + + if not input.strip("()"): + # These cases will just return True, because they will be evaluated + # and the brackets will be processed. + continue + + # Check that the non-strict eval gives us back the input when no env + # is supplied. + got = evaluate( + input, + env = {}, + strict = False, + ) + env.expect.that_bool(got).equals(input.replace("'", '"')) + +_tests.append(_logical_expression_tests) + +def _evaluate_partial_only_extra(env): + # Given + extra = "foo" + + # When + for input, want in { + "os_name == 'osx' and extra == 'bar'": False, + "os_name == 'osx' and extra == 'foo'": "os_name == \"osx\"", + "platform_system == 'aarch64' and os_name == 'osx' and extra == 'foo'": "platform_system == \"aarch64\" and os_name == \"osx\"", + "platform_system == 'aarch64' and extra == 'foo' and os_name == 'osx'": "platform_system == \"aarch64\" and os_name == \"osx\"", + "os_name == 'osx' or extra == 'bar'": "os_name == \"osx\"", + "os_name == 'osx' or extra == 'foo'": "", + "extra == 'bar' or os_name == 'osx'": "os_name == \"osx\"", + "extra == 'foo' or os_name == 'osx'": "", + "os_name == 'win' or extra == 'bar' or os_name == 'osx'": "os_name == \"win\" or os_name == \"osx\"", + "os_name == 'win' or extra == 'foo' or os_name == 'osx'": "", + }.items(): # buildifier: @unsorted-dict-items + got = evaluate( + input, + env = { + "extra": extra, + }, + strict = False, + ) + env.expect.that_bool(got).equals(want) + +_tests.append(_evaluate_partial_only_extra) + +def evaluate_test_suite(name): # buildifier: disable=function-docstring + test_suite( + name = name, + basic_tests = _tests, + ) diff --git a/tests/semver/semver_test.bzl b/tests/semver/semver_test.bzl index 9d13402c92..aef3deca82 100644 --- a/tests/semver/semver_test.bzl +++ b/tests/semver/semver_test.bzl @@ -104,6 +104,24 @@ def _test_semver_sort(env): _tests.append(_test_semver_sort) +def _test_upper(env): + for input, want in { + # Depending on how many version numbers are specified we will increase + # the upper bound differently. See https://packaging.python.org/en/latest/specifications/version-specifiers/#compatible-release for docs + "0.0.1": "0.1.0", + "0.1": "1.0", + "0.1.0": "0.2.0", + "1": "2", + "1.0.0-pre": "1.1.0", # pre-release info is dropped + "1.2.0": "1.3.0", + "2.0.0+build0": "2.1.0", # build info is dropped + }.items(): + actual = semver(input).upper().key() + want = semver(want).key() + env.expect.that_collection(actual).contains_exactly(want).in_order() + +_tests.append(_test_upper) + def semver_test_suite(name): """Create the test suite. From ae8ccfca7d2e5dab9b94a0614a683fc67b2fa3c3 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Thu, 13 Feb 2025 22:45:57 +0900 Subject: [PATCH 02/65] start reimplementation --- python/private/pypi/pep508_env.bzl | 20 ++ python/private/pypi/whl_installer/wheel.py | 1 + tests/pypi/pep508/BUILD.bazel | 5 + tests/pypi/pep508/deps_tests.bzl | 392 +++++++++++++++++++++ 4 files changed, 418 insertions(+) create mode 100644 tests/pypi/pep508/deps_tests.bzl diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index ec045737cc..2da4ab00ad 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -15,6 +15,8 @@ """This module is for implementing PEP508 environment definition. """ +load("//python/private:normalize_name.bzl", "normalize_name") + _platform_machine_values = { "aarch64": "arm64", "ppc": "ppc64le", @@ -73,3 +75,21 @@ def env(target_platform): "python_full_version": "3.{}.{}".format(minor, micro), "python_version": "3.{}".format(minor), } + +def deps(name, *, requires_dist, target_platforms = []): + """Parse the RequiresDist from wheel METADATA + + Args: + name: {type}`str` the name of the wheel. + requires_dist: {type}`list[str]` the list of RequiresDist lines from the + METADATA file. + + Returns a struct with attributes: + deps: {type}`list[str]` dependencies to include unconditionally. + deps_select: {type}`dict[str, str]` dependencies to include on particular + subset of target platforms. + """ + return struct( + deps = [normalize_name(d) for d in requires_dist], + deps_select = {}, + ) diff --git a/python/private/pypi/whl_installer/wheel.py b/python/private/pypi/whl_installer/wheel.py index 0f6bd27cdd..af71942614 100644 --- a/python/private/pypi/whl_installer/wheel.py +++ b/python/private/pypi/whl_installer/wheel.py @@ -63,6 +63,7 @@ def __init__( self.name: str = Deps._normalize(name) self._platforms: Set[Platform] = platforms or set() self._target_versions = {p.minor_version for p in platforms or {}} + self._default_minor_version = None if platforms and len(self._target_versions) > 2: # TODO @aignas 2024-06-23: enable this to be set via a CLI arg diff --git a/tests/pypi/pep508/BUILD.bazel b/tests/pypi/pep508/BUILD.bazel index b795db0591..7c6e13aec3 100644 --- a/tests/pypi/pep508/BUILD.bazel +++ b/tests/pypi/pep508/BUILD.bazel @@ -1,5 +1,10 @@ +load(":deps_tests.bzl", "deps_test_suite") load(":evaluate_tests.bzl", "evaluate_test_suite") evaluate_test_suite( name = "evaluate_tests", ) + +deps_test_suite( + name = "deps_tests", +) diff --git a/tests/pypi/pep508/deps_tests.bzl b/tests/pypi/pep508/deps_tests.bzl new file mode 100644 index 0000000000..4eab4c7598 --- /dev/null +++ b/tests/pypi/pep508/deps_tests.bzl @@ -0,0 +1,392 @@ +# Copyright 2025 The Bazel Authors. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Tests for construction of Python version matching config settings.""" + +load("@rules_testing//lib:test_suite.bzl", "test_suite") +load("//python/private/pypi:pep508_env.bzl", "deps") # buildifier: disable=bzl-visibility + +_tests = [] + +def test_simple_deps(env): + got = deps( + "foo", + requires_dist = ["bar-Bar"], + ) + env.expect.that_collection(got.deps).contains_exactly(["bar_bar"]) + env.expect.that_dict(got.deps_select).contains_exactly({}) + +_tests.append(test_simple_deps) + +def deps_test_suite(name): # buildifier: disable=function-docstring + test_suite( + name = name, + basic_tests = _tests, + ) + +# class DepsTest(unittest.TestCase): +# def test_simple(self): +# deps = wheel.Deps("foo", requires_dist=["bar"]) +# +# got = deps.build() +# +# self.assertIsInstance(got, wheel.FrozenDeps) +# self.assertEqual(["bar"], got.deps) +# self.assertEqual({}, got.deps_select) +# +# def test_can_add_os_specific_deps(self): +# deps = wheel.Deps( +# "foo", +# requires_dist=[ +# "bar", +# "an_osx_dep; sys_platform=='darwin'", +# "posix_dep; os_name=='posix'", +# "win_dep; os_name=='nt'", +# ], +# platforms={ +# Platform(os=OS.linux, arch=Arch.x86_64), +# Platform(os=OS.osx, arch=Arch.x86_64), +# Platform(os=OS.osx, arch=Arch.aarch64), +# Platform(os=OS.windows, arch=Arch.x86_64), +# }, +# ) +# +# got = deps.build() +# +# self.assertEqual(["bar"], got.deps) +# self.assertEqual( +# { +# "@platforms//os:linux": ["posix_dep"], +# "@platforms//os:osx": ["an_osx_dep", "posix_dep"], +# "@platforms//os:windows": ["win_dep"], +# }, +# got.deps_select, +# ) +# +# def test_can_add_os_specific_deps_with_specific_python_version(self): +# deps = wheel.Deps( +# "foo", +# requires_dist=[ +# "bar", +# "an_osx_dep; sys_platform=='darwin'", +# "posix_dep; os_name=='posix'", +# "win_dep; os_name=='nt'", +# ], +# platforms={ +# Platform(os=OS.linux, arch=Arch.x86_64, minor_version=8), +# Platform(os=OS.osx, arch=Arch.x86_64, minor_version=8), +# Platform(os=OS.osx, arch=Arch.aarch64, minor_version=8), +# Platform(os=OS.windows, arch=Arch.x86_64, minor_version=8), +# }, +# ) +# +# got = deps.build() +# +# self.assertEqual(["bar"], got.deps) +# self.assertEqual( +# { +# "@platforms//os:linux": ["posix_dep"], +# "@platforms//os:osx": ["an_osx_dep", "posix_dep"], +# "@platforms//os:windows": ["win_dep"], +# }, +# got.deps_select, +# ) +# +# def test_deps_are_added_to_more_specialized_platforms(self): +# got = wheel.Deps( +# "foo", +# requires_dist=[ +# "m1_dep; sys_platform=='darwin' and platform_machine=='arm64'", +# "mac_dep; sys_platform=='darwin'", +# ], +# platforms={ +# Platform(os=OS.osx, arch=Arch.x86_64), +# Platform(os=OS.osx, arch=Arch.aarch64), +# }, +# ).build() +# +# self.assertEqual( +# wheel.FrozenDeps( +# deps=[], +# deps_select={ +# "osx_aarch64": ["m1_dep", "mac_dep"], +# "@platforms//os:osx": ["mac_dep"], +# }, +# ), +# got, +# ) +# +# def test_deps_from_more_specialized_platforms_are_propagated(self): +# got = wheel.Deps( +# "foo", +# requires_dist=[ +# "a_mac_dep; sys_platform=='darwin'", +# "m1_dep; sys_platform=='darwin' and platform_machine=='arm64'", +# ], +# platforms={ +# Platform(os=OS.osx, arch=Arch.x86_64), +# Platform(os=OS.osx, arch=Arch.aarch64), +# }, +# ).build() +# +# self.assertEqual([], got.deps) +# self.assertEqual( +# { +# "osx_aarch64": ["a_mac_dep", "m1_dep"], +# "@platforms//os:osx": ["a_mac_dep"], +# }, +# got.deps_select, +# ) +# +# def test_non_platform_markers_are_added_to_common_deps(self): +# got = wheel.Deps( +# "foo", +# requires_dist=[ +# "bar", +# "baz; implementation_name=='cpython'", +# "m1_dep; sys_platform=='darwin' and platform_machine=='arm64'", +# ], +# platforms={ +# Platform(os=OS.linux, arch=Arch.x86_64), +# Platform(os=OS.osx, arch=Arch.x86_64), +# Platform(os=OS.osx, arch=Arch.aarch64), +# Platform(os=OS.windows, arch=Arch.x86_64), +# }, +# ).build() +# +# self.assertEqual(["bar", "baz"], got.deps) +# self.assertEqual( +# { +# "osx_aarch64": ["m1_dep"], +# }, +# got.deps_select, +# ) +# +# def test_self_is_ignored(self): +# deps = wheel.Deps( +# "foo", +# requires_dist=[ +# "bar", +# "req_dep; extra == 'requests'", +# "foo[requests]; extra == 'ssl'", +# "ssl_lib; extra == 'ssl'", +# ], +# extras={"ssl"}, +# ) +# +# got = deps.build() +# +# self.assertEqual(["bar", "req_dep", "ssl_lib"], got.deps) +# self.assertEqual({}, got.deps_select) +# +# def test_self_dependencies_can_come_in_any_order(self): +# deps = wheel.Deps( +# "foo", +# requires_dist=[ +# "bar", +# "baz; extra == 'feat'", +# "foo[feat2]; extra == 'all'", +# "foo[feat]; extra == 'feat2'", +# "zdep; extra == 'all'", +# ], +# extras={"all"}, +# ) +# +# got = deps.build() +# +# self.assertEqual(["bar", "baz", "zdep"], got.deps) +# self.assertEqual({}, got.deps_select) +# +# def test_can_get_deps_based_on_specific_python_version(self): +# requires_dist = [ +# "bar", +# "baz; python_version < '3.8'", +# "posix_dep; os_name=='posix' and python_version >= '3.8'", +# ] +# +# py38_deps = wheel.Deps( +# "foo", +# requires_dist=requires_dist, +# platforms=[ +# Platform(os=OS.linux, arch=Arch.x86_64, minor_version=8), +# ], +# ).build() +# py37_deps = wheel.Deps( +# "foo", +# requires_dist=requires_dist, +# platforms=[ +# Platform(os=OS.linux, arch=Arch.x86_64, minor_version=7), +# ], +# ).build() +# +# self.assertEqual(["bar", "baz"], py37_deps.deps) +# self.assertEqual({}, py37_deps.deps_select) +# self.assertEqual(["bar"], py38_deps.deps) +# self.assertEqual({"@platforms//os:linux": ["posix_dep"]}, py38_deps.deps_select) +# +# @mock.patch(_HOST_INTERPRETER_FN) +# def test_no_version_select_when_single_version(self, mock_host_interpreter_version): +# requires_dist = [ +# "bar", +# "baz; python_version >= '3.8'", +# "posix_dep; os_name=='posix'", +# "posix_dep_with_version; os_name=='posix' and python_version >= '3.8'", +# "arch_dep; platform_machine=='x86_64' and python_version >= '3.8'", +# ] +# mock_host_interpreter_version.return_value = 7 +# +# self.maxDiff = None +# +# deps = wheel.Deps( +# "foo", +# requires_dist=requires_dist, +# platforms=[ +# Platform(os=os, arch=Arch.x86_64, minor_version=minor) +# for minor in [8] +# for os in [OS.linux, OS.windows] +# ], +# ) +# got = deps.build() +# +# self.assertEqual(["bar", "baz"], got.deps) +# self.assertEqual( +# { +# "@platforms//os:linux": ["posix_dep", "posix_dep_with_version"], +# "linux_x86_64": ["arch_dep", "posix_dep", "posix_dep_with_version"], +# "windows_x86_64": ["arch_dep"], +# }, +# got.deps_select, +# ) +# +# @mock.patch(_HOST_INTERPRETER_FN) +# def test_can_get_version_select(self, mock_host_interpreter_version): +# requires_dist = [ +# "bar", +# "baz; python_version < '3.8'", +# "baz_new; python_version >= '3.8'", +# "posix_dep; os_name=='posix'", +# "posix_dep_with_version; os_name=='posix' and python_version >= '3.8'", +# "arch_dep; platform_machine=='x86_64' and python_version < '3.8'", +# ] +# mock_host_interpreter_version.return_value = 7 +# +# self.maxDiff = None +# +# deps = wheel.Deps( +# "foo", +# requires_dist=requires_dist, +# platforms=[ +# Platform(os=os, arch=Arch.x86_64, minor_version=minor) +# for minor in [7, 8, 9] +# for os in [OS.linux, OS.windows] +# ], +# ) +# got = deps.build() +# +# self.assertEqual(["bar"], got.deps) +# self.assertEqual( +# { +# "//conditions:default": ["baz"], +# "@//python/config_settings:is_python_3.7": ["baz"], +# "@//python/config_settings:is_python_3.8": ["baz_new"], +# "@//python/config_settings:is_python_3.9": ["baz_new"], +# "@platforms//os:linux": ["baz", "posix_dep"], +# "cp37_linux_x86_64": ["arch_dep", "baz", "posix_dep"], +# "cp37_windows_x86_64": ["arch_dep", "baz"], +# "cp37_linux_anyarch": ["baz", "posix_dep"], +# "cp38_linux_anyarch": [ +# "baz_new", +# "posix_dep", +# "posix_dep_with_version", +# ], +# "cp39_linux_anyarch": [ +# "baz_new", +# "posix_dep", +# "posix_dep_with_version", +# ], +# "linux_x86_64": ["arch_dep", "baz", "posix_dep"], +# "windows_x86_64": ["arch_dep", "baz"], +# }, +# got.deps_select, +# ) +# +# @mock.patch(_HOST_INTERPRETER_FN) +# def test_deps_spanning_all_target_py_versions_are_added_to_common( +# self, mock_host_version +# ): +# requires_dist = [ +# "bar", +# "baz (<2,>=1.11) ; python_version < '3.8'", +# "baz (<2,>=1.14) ; python_version >= '3.8'", +# ] +# mock_host_version.return_value = 8 +# +# deps = wheel.Deps( +# "foo", +# requires_dist=requires_dist, +# platforms=Platform.from_string(["cp37_*", "cp38_*", "cp39_*"]), +# ) +# got = deps.build() +# +# self.assertEqual(["bar", "baz"], got.deps) +# self.assertEqual({}, got.deps_select) +# +# @mock.patch(_HOST_INTERPRETER_FN) +# def test_deps_are_not_duplicated(self, mock_host_version): +# mock_host_version.return_value = 7 +# +# # See an example in +# # https://files.pythonhosted.org/packages/76/9e/db1c2d56c04b97981c06663384f45f28950a73d9acf840c4006d60d0a1ff/opencv_python-4.9.0.80-cp37-abi3-win32.whl.metadata +# requires_dist = [ +# "bar >=0.1.0 ; python_version < '3.7'", +# "bar >=0.2.0 ; python_version >= '3.7'", +# "bar >=0.4.0 ; python_version >= '3.6' and platform_system == 'Linux' and platform_machine == 'aarch64'", +# "bar >=0.4.0 ; python_version >= '3.9'", +# "bar >=0.5.0 ; python_version <= '3.9' and platform_system == 'Darwin' and platform_machine == 'arm64'", +# "bar >=0.5.0 ; python_version >= '3.10' and platform_system == 'Darwin'", +# "bar >=0.5.0 ; python_version >= '3.10'", +# "bar >=0.6.0 ; python_version >= '3.11'", +# ] +# +# deps = wheel.Deps( +# "foo", +# requires_dist=requires_dist, +# platforms=Platform.from_string(["cp37_*", "cp310_*"]), +# ) +# got = deps.build() +# +# self.assertEqual(["bar"], got.deps) +# self.assertEqual({}, got.deps_select) +# +# @mock.patch(_HOST_INTERPRETER_FN) +# def test_deps_are_not_duplicated_when_encountering_platform_dep_first( +# self, mock_host_version +# ): +# mock_host_version.return_value = 7 +# +# # Note, that we are sorting the incoming `requires_dist` and we need to ensure that we are not getting any +# # issues even if the platform-specific line comes first. +# requires_dist = [ +# "bar >=0.4.0 ; python_version >= '3.6' and platform_system == 'Linux' and platform_machine == 'aarch64'", +# "bar >=0.5.0 ; python_version >= '3.9'", +# ] +# +# deps = wheel.Deps( +# "foo", +# requires_dist=requires_dist, +# platforms=Platform.from_string(["cp37_*", "cp310_*"]), +# ) +# got = deps.build() +# +# self.assertEqual(["bar"], got.deps) +# self.assertEqual({}, got.deps_select) From bccecf2b311932ffb06089a1aeed9830c6812134 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Thu, 13 Feb 2025 23:13:17 +0900 Subject: [PATCH 03/65] continue with the tests --- python/private/pypi/pep508_env.bzl | 359 ++++++++++++++++++++++++++++- tests/pypi/pep508/deps_tests.bzl | 64 +++-- 2 files changed, 381 insertions(+), 42 deletions(-) diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 2da4ab00ad..e2918198ce 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -16,6 +16,7 @@ """ load("//python/private:normalize_name.bzl", "normalize_name") +load(":pep508_evaluate.bzl", "evaluate") _platform_machine_values = { "aarch64": "arm64", @@ -76,20 +77,370 @@ def env(target_platform): "python_version": "3.{}".format(minor), } -def deps(name, *, requires_dist, target_platforms = []): +def deps(name, *, requires_dist, platforms = []): """Parse the RequiresDist from wheel METADATA Args: name: {type}`str` the name of the wheel. requires_dist: {type}`list[str]` the list of RequiresDist lines from the METADATA file. + platforms: {type}`list[str]` the list of target platform strings. Returns a struct with attributes: deps: {type}`list[str]` dependencies to include unconditionally. - deps_select: {type}`dict[str, str]` dependencies to include on particular + deps_select: {type}`dict[str, list[str]]` dependencies to include on particular subset of target platforms. """ + envs = [env(p) for p in platforms] + + reqs = sorted( + [_req(r) for r in requires_dist], + key = lambda x: x.name, + ) + deps = [] + deps_select = {} + + for req in reqs: + _add_req(deps, deps_select, req, platforms) + return struct( - deps = [normalize_name(d) for d in requires_dist], - deps_select = {}, + deps = deps, + deps_select = deps_select, ) + +def _req(requires_dist): + requires, _, marker = requires_dist.partition(";") + return struct( + name = normalize_name(requires), + marker = marker.strip(" "), + ) + +def _add_req(deps, deps_select, req, platforms): + if not req.marker: + _add(deps, deps_select, req.name, None) + return + + # NOTE @aignas 2023-12-08: in order to have reasonable select statements + # we do have to have some parsing of the markers, so it begs the question + # if packaging should be reimplemented in Starlark to have the best solution + # for now we will implement it in Python and see what the best parsing result + # can be before making this decision. + match_os = len([ + tag + for tag in [ + "os_name", + "sys_platform", + "platform_system", + ] + if tag in req.marker + ]) > 0 + + for plat in platforms: + if not evaluate(req.marker, env = env(plat)): + continue + + if match_os: + _add(deps, deps_select, req.name, _platform_os(plat)) + else: + fail("TODO") + +def _platform_os(p): + _, _, p = p.partition("_") + os, _, _ = p.partition("_") + return "@platforms//os:" + os + +def _add(deps, deps_select, dep, platform): + dep = normalize_name(dep) + + if platform: + # Add the platform-specific dep + deps = deps_select.setdefault(platform, []) + + if dep not in deps: + deps.append(dep) + return + +# if not self._platforms: +# if any(req.marker.evaluate({"extra": extra}) for extra in extras): +# self._add(req.name, None) +# return + +# # NOTE @aignas 2023-12-08: in order to have reasonable select statements +# # we do have to have some parsing of the markers, so it begs the question +# # if packaging should be reimplemented in Starlark to have the best solution +# # for now we will implement it in Python and see what the best parsing result +# # can be before making this decision. +# match_os = any( +# tag in marker_str +# for tag in [ +# "os_name", +# "sys_platform", +# "platform_system", +# ] +# ) +# match_arch = "platform_machine" in marker_str +# match_version = "version" in marker_str + +# if not (match_os or match_arch or match_version): +# if any(req.marker.evaluate({"extra": extra}) for extra in extras): +# self._add(req.name, None) +# return + +# for plat in self._platforms: +# if not any( +# req.marker.evaluate(plat.env_markers(extra)) for extra in extras +# ): +# continue + +# if match_arch and self._default_minor_version: +# self._add(req.name, plat) +# if plat.minor_version == self._default_minor_version: +# self._add(req.name, Platform(plat.os, plat.arch)) +# elif match_arch: +# self._add(req.name, Platform(plat.os, plat.arch)) +# elif match_os and self._default_minor_version: +# self._add(req.name, Platform(plat.os, minor_version=plat.minor_version)) +# if plat.minor_version == self._default_minor_version: +# self._add(req.name, Platform(plat.os)) +# elif match_os: +# self._add(req.name, Platform(plat.os)) +# elif match_version and self._default_minor_version: +# self._add(req.name, Platform(minor_version=plat.minor_version)) +# if plat.minor_version == self._default_minor_version: +# self._add(req.name, Platform()) +# elif match_version: +# self._add(req.name, None) + +# # Merge to common if possible after processing all platforms +# self._maybe_add_common_dep(req.name) + +# self.name: str = Deps._normalize(name) +# self._platforms: Set[Platform] = platforms or set() +# self._target_versions = {p.minor_version for p in platforms or {}} + +# self._default_minor_version = None +# if platforms and len(self._target_versions) > 2: +# # TODO @aignas 2024-06-23: enable this to be set via a CLI arg +# # for being more explicit. +# self._default_minor_version = host_interpreter_minor_version() + +# if None in self._target_versions and len(self._target_versions) > 2: +# raise ValueError( +# f"all python versions need to be specified explicitly, got: {platforms}" +# ) + +# # Sort so that the dictionary order in the FrozenDeps is deterministic +# # without the final sort because Python retains insertion order. That way +# # the sorting by platform is limited within the Platform class itself and +# # the unit-tests for the Deps can be simpler. +# reqs = sorted( +# (Requirement(wheel_req) for wheel_req in requires_dist), +# key=lambda x: f"{x.name}:{sorted(x.extras)}", +# ) + +# want_extras = self._resolve_extras(reqs, extras) + +# # Then add all of the requirements in order +# self._deps: Set[str] = set() +# self._select: Dict[Platform, Set[str]] = defaultdict(set) +# for req in reqs: +# self._add_req(req, want_extras) + +# def _add(self, dep: str, platform: Optional[Platform]): +# dep = Deps._normalize(dep) + +# # Self-edges are processed in _resolve_extras +# if dep == self.name: +# return + +# if not platform: +# self._deps.add(dep) + +# # If the dep is in the platform-specific list, remove it from the select. +# pop_keys = [] +# for p, deps in self._select.items(): +# if dep not in deps: +# continue + +# deps.remove(dep) +# if not deps: +# pop_keys.append(p) + +# for p in pop_keys: +# self._select.pop(p) +# return + +# if dep in self._deps: +# # If the dep is already in the main dependency list, no need to add it in the +# # platform-specific dependency list. +# return + +# # Add the platform-specific dep +# self._select[platform].add(dep) + +# # Add the dep to specializations of the given platform if they +# # exist in the select statement. +# for p in platform.all_specializations(): +# if p not in self._select: +# continue + +# self._select[p].add(dep) + +# if len(self._select[platform]) == 1: +# # We are adding a new item to the select and we need to ensure that +# # existing dependencies from less specialized platforms are propagated +# # to the newly added dependency set. +# for p, deps in self._select.items(): +# # Check if the existing platform overlaps with the given platform +# if p == platform or platform not in p.all_specializations(): +# continue + +# self._select[platform].update(self._select[p]) + +# def _maybe_add_common_dep(self, dep): +# if len(self._target_versions) < 2: +# return + +# platforms = [Platform()] + [ +# Platform(minor_version=v) for v in self._target_versions +# ] + +# # If the dep is targeting all target python versions, lets add it to +# # the common dependency list to simplify the select statements. +# for p in platforms: +# if p not in self._select: +# return + +# if dep not in self._select[p]: +# return + +# # All of the python version-specific branches have the dep, so lets add +# # it to the common deps. +# self._deps.add(dep) +# for p in platforms: +# self._select[p].remove(dep) +# if not self._select[p]: +# self._select.pop(p) + +# def _resolve_extras( +# self, reqs: List[Requirement], extras: Optional[Set[str]] +# ) -> Set[str]: +# """Resolve extras which are due to depending on self[some_other_extra]. + +# Some packages may have cyclic dependencies resulting from extras being used, one example is +# `etils`, where we have one set of extras as aliases for other extras +# and we have an extra called 'all' that includes all other extras. + +# Example: github.com/google/etils/blob/a0b71032095db14acf6b33516bca6d885fe09e35/pyproject.toml#L32. + +# When the `requirements.txt` is generated by `pip-tools`, then it is likely that +# this step is not needed, but for other `requirements.txt` files this may be useful. + +# NOTE @aignas 2023-12-08: the extra resolution is not platform dependent, +# but in order for it to become platform dependent we would have to have +# separate targets for each extra in extras. +# """ + +# # Resolve any extra extras due to self-edges, empty string means no +# # extras The empty string in the set is just a way to make the handling +# # of no extras and a single extra easier and having a set of {"", "foo"} +# # is equivalent to having {"foo"}. +# extras = extras or {""} + +# self_reqs = [] +# for req in reqs: +# if Deps._normalize(req.name) != self.name: +# continue + +# if req.marker is None: +# # I am pretty sure we cannot reach this code as it does not +# # make sense to specify packages in this way, but since it is +# # easy to handle, lets do it. +# # +# # TODO @aignas 2023-12-08: add a test +# extras = extras | req.extras +# else: +# # process these in a separate loop +# self_reqs.append(req) + +# # A double loop is not strictly optimal, but always correct without recursion +# for req in self_reqs: +# if any(req.marker.evaluate({"extra": extra}) for extra in extras): +# extras = extras | req.extras +# else: +# continue + +# # Iterate through all packages to ensure that we include all of the extras from previously +# # visited packages. +# for req_ in self_reqs: +# if any(req_.marker.evaluate({"extra": extra}) for extra in extras): +# extras = extras | req_.extras + +# return extras + +# def _add_req(self, req: Requirement, extras: Set[str]) -> None: +# if req.marker is None: +# self._add(req.name, None) +# return + +# marker_str = str(req.marker) + +# if not self._platforms: +# if any(req.marker.evaluate({"extra": extra}) for extra in extras): +# self._add(req.name, None) +# return + +# # NOTE @aignas 2023-12-08: in order to have reasonable select statements +# # we do have to have some parsing of the markers, so it begs the question +# # if packaging should be reimplemented in Starlark to have the best solution +# # for now we will implement it in Python and see what the best parsing result +# # can be before making this decision. +# match_os = any( +# tag in marker_str +# for tag in [ +# "os_name", +# "sys_platform", +# "platform_system", +# ] +# ) +# match_arch = "platform_machine" in marker_str +# match_version = "version" in marker_str + +# if not (match_os or match_arch or match_version): +# if any(req.marker.evaluate({"extra": extra}) for extra in extras): +# self._add(req.name, None) +# return + +# for plat in self._platforms: +# if not any( +# req.marker.evaluate(plat.env_markers(extra)) for extra in extras +# ): +# continue + +# if match_arch and self._default_minor_version: +# self._add(req.name, plat) +# if plat.minor_version == self._default_minor_version: +# self._add(req.name, Platform(plat.os, plat.arch)) +# elif match_arch: +# self._add(req.name, Platform(plat.os, plat.arch)) +# elif match_os and self._default_minor_version: +# self._add(req.name, Platform(plat.os, minor_version=plat.minor_version)) +# if plat.minor_version == self._default_minor_version: +# self._add(req.name, Platform(plat.os)) +# elif match_os: +# self._add(req.name, Platform(plat.os)) +# elif match_version and self._default_minor_version: +# self._add(req.name, Platform(minor_version=plat.minor_version)) +# if plat.minor_version == self._default_minor_version: +# self._add(req.name, Platform()) +# elif match_version: +# self._add(req.name, None) + +# # Merge to common if possible after processing all platforms +# self._maybe_add_common_dep(req.name) + +# def build(self) -> FrozenDeps: +# return FrozenDeps( +# deps=sorted(self._deps), +# deps_select={str(p): sorted(deps) for p, deps in self._select.items()}, +# ) diff --git a/tests/pypi/pep508/deps_tests.bzl b/tests/pypi/pep508/deps_tests.bzl index 4eab4c7598..fd095857f7 100644 --- a/tests/pypi/pep508/deps_tests.bzl +++ b/tests/pypi/pep508/deps_tests.bzl @@ -28,6 +28,32 @@ def test_simple_deps(env): _tests.append(test_simple_deps) +def test_can_add_os_specific_deps(env): + got = deps( + "foo", + requires_dist = [ + "bar", + "an_osx_dep; sys_platform=='darwin'", + "posix_dep; os_name=='posix'", + "win_dep; os_name=='nt'", + ], + platforms = [ + "cp33_linux_x86_64", + "cp33_osx_x86_64", + "cp33_osx_aarch64", + "cp33_windows_x86_64", + ], + ) + + env.expect.that_collection(got.deps).contains_exactly(["bar"]) + env.expect.that_dict(got.deps_select).contains_exactly({ + "@platforms//os:linux": ["posix_dep"], + "@platforms//os:osx": ["an_osx_dep", "posix_dep"], + "@platforms//os:windows": ["win_dep"], + }) + +_tests.append(test_can_add_os_specific_deps) + def deps_test_suite(name): # buildifier: disable=function-docstring test_suite( name = name, @@ -35,44 +61,6 @@ def deps_test_suite(name): # buildifier: disable=function-docstring ) # class DepsTest(unittest.TestCase): -# def test_simple(self): -# deps = wheel.Deps("foo", requires_dist=["bar"]) -# -# got = deps.build() -# -# self.assertIsInstance(got, wheel.FrozenDeps) -# self.assertEqual(["bar"], got.deps) -# self.assertEqual({}, got.deps_select) -# -# def test_can_add_os_specific_deps(self): -# deps = wheel.Deps( -# "foo", -# requires_dist=[ -# "bar", -# "an_osx_dep; sys_platform=='darwin'", -# "posix_dep; os_name=='posix'", -# "win_dep; os_name=='nt'", -# ], -# platforms={ -# Platform(os=OS.linux, arch=Arch.x86_64), -# Platform(os=OS.osx, arch=Arch.x86_64), -# Platform(os=OS.osx, arch=Arch.aarch64), -# Platform(os=OS.windows, arch=Arch.x86_64), -# }, -# ) -# -# got = deps.build() -# -# self.assertEqual(["bar"], got.deps) -# self.assertEqual( -# { -# "@platforms//os:linux": ["posix_dep"], -# "@platforms//os:osx": ["an_osx_dep", "posix_dep"], -# "@platforms//os:windows": ["win_dep"], -# }, -# got.deps_select, -# ) -# # def test_can_add_os_specific_deps_with_specific_python_version(self): # deps = wheel.Deps( # "foo", From d4173e1b90faef818e2a3699326cc6ea69ab6540 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Fri, 14 Feb 2025 09:01:59 +0900 Subject: [PATCH 04/65] add python_version arg to deps --- python/private/pypi/pep508_env.bzl | 27 ++++++++++---- tests/pypi/pep508/deps_tests.bzl | 58 +++++++++++++++--------------- 2 files changed, 48 insertions(+), 37 deletions(-) diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index e2918198ce..638efc281a 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -77,7 +77,7 @@ def env(target_platform): "python_version": "3.{}".format(minor), } -def deps(name, *, requires_dist, platforms = []): +def deps(name, *, requires_dist, platforms = [], python_version = None): """Parse the RequiresDist from wheel METADATA Args: @@ -85,14 +85,14 @@ def deps(name, *, requires_dist, platforms = []): requires_dist: {type}`list[str]` the list of RequiresDist lines from the METADATA file. platforms: {type}`list[str]` the list of target platform strings. + python_version: {type}`str` the host python version. - Returns a struct with attributes: - deps: {type}`list[str]` dependencies to include unconditionally. - deps_select: {type}`dict[str, list[str]]` dependencies to include on particular - subset of target platforms. + Returns: + A struct with attributes: + * deps: {type}`list[str]` dependencies to include unconditionally. + * deps_select: {type}`dict[str, list[str]]` dependencies to include on particular + subset of target platforms. """ - envs = [env(p) for p in platforms] - reqs = sorted( [_req(r) for r in requires_dist], key = lambda x: x.name, @@ -100,6 +100,10 @@ def deps(name, *, requires_dist, platforms = []): deps = [] deps_select = {} + platforms = [ + _versioned_platform(p, python_version) + for p in platforms + ] for req in reqs: _add_req(deps, deps_select, req, platforms) @@ -108,6 +112,15 @@ def deps(name, *, requires_dist, platforms = []): deps_select = deps_select, ) +def _versioned_platform(os_arch, python_version): + if not python_version or os_arch.startswith("cp"): + # This also has ABI + return os_arch + + major, _, tail = python_version.partition(".") + minor, _, _ = tail.partition(".") + return "cp{}{}_{}".format(major, minor, os_arch) + def _req(requires_dist): requires, _, marker = requires_dist.partition(";") return struct( diff --git a/tests/pypi/pep508/deps_tests.bzl b/tests/pypi/pep508/deps_tests.bzl index fd095857f7..b8bf8e4ce8 100644 --- a/tests/pypi/pep508/deps_tests.bzl +++ b/tests/pypi/pep508/deps_tests.bzl @@ -29,6 +29,33 @@ def test_simple_deps(env): _tests.append(test_simple_deps) def test_can_add_os_specific_deps(env): + got = deps( + "foo", + requires_dist = [ + "bar", + "an_osx_dep; sys_platform=='darwin'", + "posix_dep; os_name=='posix'", + "win_dep; os_name=='nt'", + ], + platforms = [ + "linux_x86_64", + "osx_x86_64", + "osx_aarch64", + "windows_x86_64", + ], + python_version = "3.3.1", + ) + + env.expect.that_collection(got.deps).contains_exactly(["bar"]) + env.expect.that_dict(got.deps_select).contains_exactly({ + "@platforms//os:linux": ["posix_dep"], + "@platforms//os:osx": ["an_osx_dep", "posix_dep"], + "@platforms//os:windows": ["win_dep"], + }) + +_tests.append(test_can_add_os_specific_deps) + +def test_can_add_os_specific_deps_with_python_version(env): got = deps( "foo", requires_dist = [ @@ -52,7 +79,7 @@ def test_can_add_os_specific_deps(env): "@platforms//os:windows": ["win_dep"], }) -_tests.append(test_can_add_os_specific_deps) +_tests.append(test_can_add_os_specific_deps_with_python_version) def deps_test_suite(name): # buildifier: disable=function-docstring test_suite( @@ -61,35 +88,6 @@ def deps_test_suite(name): # buildifier: disable=function-docstring ) # class DepsTest(unittest.TestCase): -# def test_can_add_os_specific_deps_with_specific_python_version(self): -# deps = wheel.Deps( -# "foo", -# requires_dist=[ -# "bar", -# "an_osx_dep; sys_platform=='darwin'", -# "posix_dep; os_name=='posix'", -# "win_dep; os_name=='nt'", -# ], -# platforms={ -# Platform(os=OS.linux, arch=Arch.x86_64, minor_version=8), -# Platform(os=OS.osx, arch=Arch.x86_64, minor_version=8), -# Platform(os=OS.osx, arch=Arch.aarch64, minor_version=8), -# Platform(os=OS.windows, arch=Arch.x86_64, minor_version=8), -# }, -# ) -# -# got = deps.build() -# -# self.assertEqual(["bar"], got.deps) -# self.assertEqual( -# { -# "@platforms//os:linux": ["posix_dep"], -# "@platforms//os:osx": ["an_osx_dep", "posix_dep"], -# "@platforms//os:windows": ["win_dep"], -# }, -# got.deps_select, -# ) -# # def test_deps_are_added_to_more_specialized_platforms(self): # got = wheel.Deps( # "foo", From 84ba241ab356bdbef2f4a3ddb99bb920199a7712 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Fri, 14 Feb 2025 09:16:47 +0900 Subject: [PATCH 05/65] wip --- python/private/pypi/pep508_env.bzl | 31 +++++++++++++++++--- tests/pypi/pep508/deps_tests.bzl | 46 ++++++++++++++---------------- 2 files changed, 49 insertions(+), 28 deletions(-) diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 638efc281a..d38c844540 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -147,12 +147,15 @@ def _add_req(deps, deps_select, req, platforms): ] if tag in req.marker ]) > 0 + match_arch = "platform_machine" in req.marker for plat in platforms: if not evaluate(req.marker, env = env(plat)): continue - if match_os: + if match_arch: + _add(deps, deps_select, req.name, _platform_os_arch(plat)) + elif match_os: _add(deps, deps_select, req.name, _platform_os(plat)) else: fail("TODO") @@ -162,16 +165,36 @@ def _platform_os(p): os, _, _ = p.partition("_") return "@platforms//os:" + os +def _platform_os_arch(p): + _, _, p = p.partition("_") + os, _, arch = p.partition("_") + return "{}_{}".format(os, arch) + +def _platform_specializations(p): + return [] + def _add(deps, deps_select, dep, platform): dep = normalize_name(dep) + add_to = [] if platform: # Add the platform-specific dep deps = deps_select.setdefault(platform, []) + add_to.append(deps) - if dep not in deps: - deps.append(dep) - return + for p in _platform_specializations(platform): + if p not in deps_select: + continue + + deps = deps_select.get(p) + if deps: + add_to.append(deps) + else: + add_to.append(deps) + + for deps in add_to: + if dep not in deps: + deps.append(dep) # if not self._platforms: # if any(req.marker.evaluate({"extra": extra}) for extra in extras): diff --git a/tests/pypi/pep508/deps_tests.bzl b/tests/pypi/pep508/deps_tests.bzl index b8bf8e4ce8..8675673603 100644 --- a/tests/pypi/pep508/deps_tests.bzl +++ b/tests/pypi/pep508/deps_tests.bzl @@ -81,6 +81,28 @@ def test_can_add_os_specific_deps_with_python_version(env): _tests.append(test_can_add_os_specific_deps_with_python_version) +def test_deps_are_added_to_more_specialized_platforms(env): + got = deps( + "foo", + requires_dist = [ + "m1_dep; sys_platform=='darwin' and platform_machine=='arm64'", + "mac_dep; sys_platform=='darwin'", + ], + platforms = [ + "osx_x86_64", + "osx_aarch64", + ], + python_version = "3.8", + ) + + env.expect.that_collection(got.deps).contains_exactly([]) + env.expect.that_dict(got.deps_select).contains_exactly({ + "@platforms//os:osx": ["mac_dep"], + "osx_aarch64": ["m1_dep", "mac_dep"], + }) + +_tests.append(test_deps_are_added_to_more_specialized_platforms) + def deps_test_suite(name): # buildifier: disable=function-docstring test_suite( name = name, @@ -88,30 +110,6 @@ def deps_test_suite(name): # buildifier: disable=function-docstring ) # class DepsTest(unittest.TestCase): -# def test_deps_are_added_to_more_specialized_platforms(self): -# got = wheel.Deps( -# "foo", -# requires_dist=[ -# "m1_dep; sys_platform=='darwin' and platform_machine=='arm64'", -# "mac_dep; sys_platform=='darwin'", -# ], -# platforms={ -# Platform(os=OS.osx, arch=Arch.x86_64), -# Platform(os=OS.osx, arch=Arch.aarch64), -# }, -# ).build() -# -# self.assertEqual( -# wheel.FrozenDeps( -# deps=[], -# deps_select={ -# "osx_aarch64": ["m1_dep", "mac_dep"], -# "@platforms//os:osx": ["mac_dep"], -# }, -# ), -# got, -# ) -# # def test_deps_from_more_specialized_platforms_are_propagated(self): # got = wheel.Deps( # "foo", From d844dd0119e5a88d7ae265384723418a0579d3e7 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Fri, 14 Feb 2025 14:29:15 +0900 Subject: [PATCH 06/65] wip --- python/private/pypi/pep508_env.bzl | 53 +++++++++++++++++++++--------- 1 file changed, 37 insertions(+), 16 deletions(-) diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index d38c844540..078298dbbf 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -51,19 +51,19 @@ def env(target_platform): Returns: A dict that can be used as `env` in the marker evaluation. """ - abi, _, tail = target_platform.partition("_") # TODO @aignas 2024-12-26: wire up the usage of the micro version - minor, _, micro = abi[3:].partition(".") + minor, _, micro = target_platform.abi[3:].partition(".") micro = micro or "0" - os, _, cpu = tail.partition("_") + os = target_platform.os + arch = target_platform.arch # TODO @aignas 2025-02-13: consider moving this into config settings. # This is split by topic return { "os_name": _os_name_values.get(os, ""), - "platform_machine": "aarch64" if (os, cpu) == ("linux", "aarch64") else _platform_machine_values.get(cpu, ""), + "platform_machine": "aarch64" if (os, arch) == ("linux", "aarch64") else _platform_machine_values.get(arch, ""), "platform_system": _platform_system_values.get(os, ""), "sys_platform": _sys_platform_values.get(os, ""), } | { @@ -101,7 +101,7 @@ def deps(name, *, requires_dist, platforms = [], python_version = None): deps_select = {} platforms = [ - _versioned_platform(p, python_version) + _platform_from_str(_versioned_platform(p, python_version)) for p in platforms ] for req in reqs: @@ -154,23 +154,44 @@ def _add_req(deps, deps_select, req, platforms): continue if match_arch: - _add(deps, deps_select, req.name, _platform_os_arch(plat)) + _add(deps, deps_select, req.name, _platform(os = plat.os, arch = plat.arch)) elif match_os: - _add(deps, deps_select, req.name, _platform_os(plat)) + _add(deps, deps_select, req.name, _platform(os = plat.os)) else: fail("TODO") -def _platform_os(p): - _, _, p = p.partition("_") - os, _, _ = p.partition("_") - return "@platforms//os:" + os +def _platform(*, abi = None, os = None, arch = None): + return struct( + abi = abi, + os = os, + arch = arch, + ) -def _platform_os_arch(p): - _, _, p = p.partition("_") +def _platform_from_str(p): + abi, _, p = p.partition("_") os, _, arch = p.partition("_") - return "{}_{}".format(os, arch) + return _platform(abi = abi, os = os, arch = arch) + +def _platform_str(self): + if self.abi == None: + if not self.os and not self.arch: + return "//conditions:default" + elif not self.arch: + return "@platforms//os:{}".format(self.os) + else: + return "{}_{}".format(self.os, self.arch) + + minor_version = self.abi[3:] + if self.arch == None and self.os == None: + return "@//python/config_settings:is_python_3.{}".format(minor_version) + + return "cp3{}_{}_{}".format( + minor_version, + self.os or "anyos", + self.arch or "anyarch", + ) -def _platform_specializations(p): +def _platform_specializations(self): return [] def _add(deps, deps_select, dep, platform): @@ -179,7 +200,7 @@ def _add(deps, deps_select, dep, platform): if platform: # Add the platform-specific dep - deps = deps_select.setdefault(platform, []) + deps = deps_select.setdefault(_platform_str(platform), []) add_to.append(deps) for p in _platform_specializations(platform): From d11bd2bdb3e2c048ca8671bc636d0b0b91ef5dbb Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Feb 2025 09:22:26 +0900 Subject: [PATCH 07/65] wip --- python/private/pypi/pep508_env.bzl | 23 ++++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-) diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 078298dbbf..bd780fac5a 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -158,7 +158,7 @@ def _add_req(deps, deps_select, req, platforms): elif match_os: _add(deps, deps_select, req.name, _platform(os = plat.os)) else: - fail("TODO") + fail("TODO: {}".format(plat)) def _platform(*, abi = None, os = None, arch = None): return struct( @@ -192,7 +192,19 @@ def _platform_str(self): ) def _platform_specializations(self): - return [] + specializations = [] + specializations.append(self) + if self.arch == None: + specializations.extend([ + _platform(os = self.os, arch = arch, abi = self.abi) + for arch in _platform_machine_values + ]) + if self.os == None: + specializations.extend([ + _platform(os = os, arch = self.arch, abi = self.abi) + for os in _platform_system_values + ]) + return specializations def _add(deps, deps_select, dep, platform): dep = normalize_name(dep) @@ -204,12 +216,13 @@ def _add(deps, deps_select, dep, platform): add_to.append(deps) for p in _platform_specializations(platform): + p = _platform_str(p) if p not in deps_select: continue - deps = deps_select.get(p) - if deps: - add_to.append(deps) + more_specialized_deps = deps_select.get(p, []) + if dep not in more_specialized_deps: + more_specialized_deps.append(dep) else: add_to.append(deps) From 743b9928c787e29964d25dd46c1e5c17571e7655 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Feb 2025 09:23:37 +0900 Subject: [PATCH 08/65] wip --- python/private/pypi/pep508_env.bzl | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index bd780fac5a..7ebcce2c8d 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -109,7 +109,10 @@ def deps(name, *, requires_dist, platforms = [], python_version = None): return struct( deps = deps, - deps_select = deps_select, + deps_select = { + _platform_str(p): deps + for p, deps in deps_select.items() + }, ) def _versioned_platform(os_arch, python_version): From 9aa2a3f2e1f70e889f96d291aa4c4a622d3ac5b2 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Feb 2025 09:24:38 +0900 Subject: [PATCH 09/65] stringify platforms later --- python/private/pypi/pep508_env.bzl | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 7ebcce2c8d..86d04c0bf5 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -215,11 +215,10 @@ def _add(deps, deps_select, dep, platform): if platform: # Add the platform-specific dep - deps = deps_select.setdefault(_platform_str(platform), []) + deps = deps_select.setdefault(platform, []) add_to.append(deps) for p in _platform_specializations(platform): - p = _platform_str(p) if p not in deps_select: continue From 3f56e1c722b1eba8909cbcd20a167ee0d840f8ec Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Feb 2025 09:33:42 +0900 Subject: [PATCH 10/65] one more test passing --- python/private/pypi/pep508_env.bzl | 15 +++++++++- tests/pypi/pep508/deps_tests.bzl | 46 ++++++++++++++++-------------- 2 files changed, 38 insertions(+), 23 deletions(-) diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 86d04c0bf5..16dc031437 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -217,6 +217,19 @@ def _add(deps, deps_select, dep, platform): # Add the platform-specific dep deps = deps_select.setdefault(platform, []) add_to.append(deps) + if not deps: + # We are adding a new item to the select and we need to ensure that + # existing dependencies from less specialized platforms are propagated + # to the newly added dependency set. + for p, existing_deps in deps_select.items(): + # Check if the existing platform overlaps with the given platform + if p == platform or platform not in _platform_specializations(p): + continue + + # Copy existing elements from the existing specializations. + for d in existing_deps: + if d not in deps: + deps.append(d) for p in _platform_specializations(platform): if p not in deps_select: @@ -224,7 +237,7 @@ def _add(deps, deps_select, dep, platform): more_specialized_deps = deps_select.get(p, []) if dep not in more_specialized_deps: - more_specialized_deps.append(dep) + add_to.append(more_specialized_deps) else: add_to.append(deps) diff --git a/tests/pypi/pep508/deps_tests.bzl b/tests/pypi/pep508/deps_tests.bzl index 8675673603..624f877707 100644 --- a/tests/pypi/pep508/deps_tests.bzl +++ b/tests/pypi/pep508/deps_tests.bzl @@ -103,6 +103,30 @@ def test_deps_are_added_to_more_specialized_platforms(env): _tests.append(test_deps_are_added_to_more_specialized_platforms) +def test_deps_from_more_specialized_platforms_are_propagated(env): + got = deps( + "foo", + requires_dist = [ + "a_mac_dep; sys_platform=='darwin'", + "m1_dep; sys_platform=='darwin' and platform_machine=='arm64'", + ], + platforms = [ + "osx_x86_64", + "osx_aarch64", + ], + python_version = "3.8", + ) + + env.expect.that_collection(got.deps).contains_exactly([]) + env.expect.that_dict(got.deps_select).contains_exactly( + { + "@platforms//os:osx": ["a_mac_dep"], + "osx_aarch64": ["a_mac_dep", "m1_dep"], + }, + ) + +_tests.append(test_deps_from_more_specialized_platforms_are_propagated) + def deps_test_suite(name): # buildifier: disable=function-docstring test_suite( name = name, @@ -110,28 +134,6 @@ def deps_test_suite(name): # buildifier: disable=function-docstring ) # class DepsTest(unittest.TestCase): -# def test_deps_from_more_specialized_platforms_are_propagated(self): -# got = wheel.Deps( -# "foo", -# requires_dist=[ -# "a_mac_dep; sys_platform=='darwin'", -# "m1_dep; sys_platform=='darwin' and platform_machine=='arm64'", -# ], -# platforms={ -# Platform(os=OS.osx, arch=Arch.x86_64), -# Platform(os=OS.osx, arch=Arch.aarch64), -# }, -# ).build() -# -# self.assertEqual([], got.deps) -# self.assertEqual( -# { -# "osx_aarch64": ["a_mac_dep", "m1_dep"], -# "@platforms//os:osx": ["a_mac_dep"], -# }, -# got.deps_select, -# ) -# # def test_non_platform_markers_are_added_to_common_deps(self): # got = wheel.Deps( # "foo", From 5b128495e88987951723c15440b6fda0233863d1 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Feb 2025 09:41:00 +0900 Subject: [PATCH 11/65] common deps addition --- python/private/pypi/pep508_env.bzl | 6 +++- tests/pypi/pep508/deps_tests.bzl | 48 +++++++++++++++--------------- 2 files changed, 29 insertions(+), 25 deletions(-) diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 16dc031437..35f9254792 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -152,6 +152,10 @@ def _add_req(deps, deps_select, req, platforms): ]) > 0 match_arch = "platform_machine" in req.marker + if not (match_os or match_arch): + _add(deps, deps_select, req.name, None) + return + for plat in platforms: if not evaluate(req.marker, env = env(plat)): continue @@ -161,7 +165,7 @@ def _add_req(deps, deps_select, req, platforms): elif match_os: _add(deps, deps_select, req.name, _platform(os = plat.os)) else: - fail("TODO: {}".format(plat)) + fail("TODO: {}, {}".format(req.marker, plat)) def _platform(*, abi = None, os = None, arch = None): return struct( diff --git a/tests/pypi/pep508/deps_tests.bzl b/tests/pypi/pep508/deps_tests.bzl index 624f877707..cfa35c3a42 100644 --- a/tests/pypi/pep508/deps_tests.bzl +++ b/tests/pypi/pep508/deps_tests.bzl @@ -127,6 +127,30 @@ def test_deps_from_more_specialized_platforms_are_propagated(env): _tests.append(test_deps_from_more_specialized_platforms_are_propagated) +def test_non_platform_markers_are_added_to_common_deps(env): + got = deps( + "foo", + requires_dist = [ + "bar", + "baz; implementation_name=='cpython'", + "m1_dep; sys_platform=='darwin' and platform_machine=='arm64'", + ], + platforms = [ + "linux_x86_64", + "osx_x86_64", + "osx_aarch64", + "windows_x86_64", + ], + python_version = "3.8", + ) + + env.expect.that_collection(got.deps).contains_exactly(["bar", "baz"]) + env.expect.that_dict(got.deps_select).contains_exactly({ + "osx_aarch64": ["m1_dep"], + }) + +_tests.append(test_non_platform_markers_are_added_to_common_deps) + def deps_test_suite(name): # buildifier: disable=function-docstring test_suite( name = name, @@ -134,30 +158,6 @@ def deps_test_suite(name): # buildifier: disable=function-docstring ) # class DepsTest(unittest.TestCase): -# def test_non_platform_markers_are_added_to_common_deps(self): -# got = wheel.Deps( -# "foo", -# requires_dist=[ -# "bar", -# "baz; implementation_name=='cpython'", -# "m1_dep; sys_platform=='darwin' and platform_machine=='arm64'", -# ], -# platforms={ -# Platform(os=OS.linux, arch=Arch.x86_64), -# Platform(os=OS.osx, arch=Arch.x86_64), -# Platform(os=OS.osx, arch=Arch.aarch64), -# Platform(os=OS.windows, arch=Arch.x86_64), -# }, -# ).build() -# -# self.assertEqual(["bar", "baz"], got.deps) -# self.assertEqual( -# { -# "osx_aarch64": ["m1_dep"], -# }, -# got.deps_select, -# ) -# # def test_self_is_ignored(self): # deps = wheel.Deps( # "foo", From 4a22828985b64715e78a9dfca11a822bed999ce3 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Feb 2025 11:12:00 +0900 Subject: [PATCH 12/65] handle self edges --- python/private/pypi/pep508_env.bzl | 161 ++++++++++++++++++++++------- tests/pypi/pep508/deps_tests.bzl | 35 ++++--- 2 files changed, 139 insertions(+), 57 deletions(-) diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 35f9254792..64528dcf75 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -41,12 +41,13 @@ _os_name_values = { "windows": "nt", } -def env(target_platform): +def env(target_platform, *, extra = None): """Return an env target platform Args: target_platform: {type}`str` the target platform identifier, e.g. `cp33_linux_aarch64` + 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. @@ -60,6 +61,8 @@ def env(target_platform): # TODO @aignas 2025-02-13: consider moving this into config settings. + extras = {"extra": extra} if extra != None else {} + # This is split by topic return { "os_name": _os_name_values.get(os, ""), @@ -75,15 +78,16 @@ def env(target_platform): "implementation_version": "3.{}.{}".format(minor, micro), "python_full_version": "3.{}.{}".format(minor, micro), "python_version": "3.{}".format(minor), - } + } | extras -def deps(name, *, requires_dist, platforms = [], python_version = None): +def deps(name, *, requires_dist, platforms = [], extras = [], python_version = None): """Parse the RequiresDist from wheel METADATA Args: name: {type}`str` the name of the wheel. requires_dist: {type}`list[str]` the list of RequiresDist lines from the METADATA file. + extras: {type}`list[str]` the requested extras to generate targets for. platforms: {type}`list[str]` the list of target platform strings. python_version: {type}`str` the host python version. @@ -99,13 +103,19 @@ def deps(name, *, requires_dist, platforms = [], python_version = None): ) deps = [] deps_select = {} + name = normalize_name(name) + + want_extras = _resolve_extras(name, reqs, extras) + + # drop self edges + reqs = [r for r in reqs if r.name != name] platforms = [ _platform_from_str(_versioned_platform(p, python_version)) for p in platforms ] for req in reqs: - _add_req(deps, deps_select, req, platforms) + _add_req(deps, deps_select, req, extras = want_extras, platforms = platforms, python_version = python_version) return struct( deps = deps, @@ -126,47 +136,14 @@ def _versioned_platform(os_arch, python_version): def _req(requires_dist): requires, _, marker = requires_dist.partition(";") + requires, _, extras_unparsed = requires.partition("[") + extras = extras_unparsed.strip("]").split(",") return struct( name = normalize_name(requires), marker = marker.strip(" "), + extras = extras, ) -def _add_req(deps, deps_select, req, platforms): - if not req.marker: - _add(deps, deps_select, req.name, None) - return - - # NOTE @aignas 2023-12-08: in order to have reasonable select statements - # we do have to have some parsing of the markers, so it begs the question - # if packaging should be reimplemented in Starlark to have the best solution - # for now we will implement it in Python and see what the best parsing result - # can be before making this decision. - match_os = len([ - tag - for tag in [ - "os_name", - "sys_platform", - "platform_system", - ] - if tag in req.marker - ]) > 0 - match_arch = "platform_machine" in req.marker - - if not (match_os or match_arch): - _add(deps, deps_select, req.name, None) - return - - for plat in platforms: - if not evaluate(req.marker, env = env(plat)): - continue - - if match_arch: - _add(deps, deps_select, req.name, _platform(os = plat.os, arch = plat.arch)) - elif match_os: - _add(deps, deps_select, req.name, _platform(os = plat.os)) - else: - fail("TODO: {}, {}".format(req.marker, plat)) - def _platform(*, abi = None, os = None, arch = None): return struct( abi = abi, @@ -213,6 +190,55 @@ def _platform_specializations(self): ]) return specializations +def _add_req(deps, deps_select, req, *, extras, platforms, python_version = None): + if not req.marker: + _add(deps, deps_select, req.name, None) + return + + # NOTE @aignas 2023-12-08: in order to have reasonable select statements + # we do have to have some parsing of the markers, so it begs the question + # if packaging should be reimplemented in Starlark to have the best solution + # for now we will implement it in Python and see what the best parsing result + # can be before making this decision. + match_os = len([ + tag + for tag in [ + "os_name", + "sys_platform", + "platform_system", + ] + if tag in req.marker + ]) > 0 + match_arch = "platform_machine" in req.marker + + if not (match_os or match_arch): + if [ + True + for extra in extras + if evaluate( + req.marker, + env = env( + target_platform = _platform( + abi = "cp" + python_version.replace("3.", "cp3"), + ), + extra = extra, + ), + ) + ]: + _add(deps, deps_select, req.name, None) + return + + for plat in platforms: + if not evaluate(req.marker, env = env(plat)): + continue + + if match_arch: + _add(deps, deps_select, req.name, _platform(os = plat.os, arch = plat.arch)) + elif match_os: + _add(deps, deps_select, req.name, _platform(os = plat.os)) + else: + fail("TODO: {}, {}".format(req.marker, plat)) + def _add(deps, deps_select, dep, platform): dep = normalize_name(dep) add_to = [] @@ -249,6 +275,61 @@ def _add(deps, deps_select, dep, platform): if dep not in deps: deps.append(dep) +def _resolve_extras(self_name, reqs, extras): + """Resolve extras which are due to depending on self[some_other_extra]. + + Some packages may have cyclic dependencies resulting from extras being used, one example is + `etils`, where we have one set of extras as aliases for other extras + and we have an extra called 'all' that includes all other extras. + + Example: github.com/google/etils/blob/a0b71032095db14acf6b33516bca6d885fe09e35/pyproject.toml#L32. + + When the `requirements.txt` is generated by `pip-tools`, then it is likely that + this step is not needed, but for other `requirements.txt` files this may be useful. + + NOTE @aignas 2023-12-08: the extra resolution is not platform dependent, + but in order for it to become platform dependent we would have to have + separate targets for each extra in extras. + """ + + # Resolve any extra extras due to self-edges, empty string means no + # extras The empty string in the set is just a way to make the handling + # of no extras and a single extra easier and having a set of {"", "foo"} + # is equivalent to having {"foo"}. + extras = extras or [""] + + self_reqs = [] + for req in reqs: + if normalize_name(req.name) != self_name: + continue + + if req.marker == None: + # I am pretty sure we cannot reach this code as it does not + # make sense to specify packages in this way, but since it is + # easy to handle, lets do it. + # + # TODO @aignas 2023-12-08: add a test + extras = extras + req.extras + else: + # process these in a separate loop + self_reqs.append(req) + + # A double loop is not strictly optimal, but always correct without recursion + for req in self_reqs: + if [True for extra in extras if evaluate(req.marker, env = {"extra": extra})]: + extras = extras + req.extras + else: + continue + + # Iterate through all packages to ensure that we include all of the extras from previously + # visited packages. + for req_ in self_reqs: + if [True for extra in extras if evaluate(req.marker, env = {"extra": extra})]: + extras = extras + req_.extras + + # Poor mans set + return sorted({x: None for x in extras}) + # if not self._platforms: # if any(req.marker.evaluate({"extra": extra}) for extra in extras): # self._add(req.name, None) diff --git a/tests/pypi/pep508/deps_tests.bzl b/tests/pypi/pep508/deps_tests.bzl index cfa35c3a42..fc9780b065 100644 --- a/tests/pypi/pep508/deps_tests.bzl +++ b/tests/pypi/pep508/deps_tests.bzl @@ -151,6 +151,24 @@ def test_non_platform_markers_are_added_to_common_deps(env): _tests.append(test_non_platform_markers_are_added_to_common_deps) +def test_self_is_ignored(env): + got = deps( + "foo", + requires_dist = [ + "bar", + "req_dep; extra == 'requests'", + "foo[requests]; extra == 'ssl'", + "ssl_lib; extra == 'ssl'", + ], + extras = ["ssl"], + python_version = "3.8", + ) + + env.expect.that_collection(got.deps).contains_exactly(["bar", "req_dep", "ssl_lib"]) + env.expect.that_dict(got.deps_select).contains_exactly({}) + +_tests.append(test_self_is_ignored) + def deps_test_suite(name): # buildifier: disable=function-docstring test_suite( name = name, @@ -158,23 +176,6 @@ def deps_test_suite(name): # buildifier: disable=function-docstring ) # class DepsTest(unittest.TestCase): -# def test_self_is_ignored(self): -# deps = wheel.Deps( -# "foo", -# requires_dist=[ -# "bar", -# "req_dep; extra == 'requests'", -# "foo[requests]; extra == 'ssl'", -# "ssl_lib; extra == 'ssl'", -# ], -# extras={"ssl"}, -# ) -# -# got = deps.build() -# -# self.assertEqual(["bar", "req_dep", "ssl_lib"], got.deps) -# self.assertEqual({}, got.deps_select) -# # def test_self_dependencies_can_come_in_any_order(self): # deps = wheel.Deps( # "foo", From b68db5b6bf751e718ebf7c743696ce800dd6d109 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Feb 2025 11:27:02 +0900 Subject: [PATCH 13/65] self deps and specific python version deps --- python/private/pypi/pep508_env.bzl | 13 +++-- tests/pypi/pep508/deps_tests.bzl | 87 +++++++++++++++--------------- 2 files changed, 52 insertions(+), 48 deletions(-) diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 64528dcf75..01254d47b7 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -114,8 +114,12 @@ def deps(name, *, requires_dist, platforms = [], extras = [], python_version = N _platform_from_str(_versioned_platform(p, python_version)) for p in platforms ] + if not platforms and python_version: + platforms.append(_platform( + abi = "cp" + python_version.replace("3.", "cp3"), + )) for req in reqs: - _add_req(deps, deps_select, req, extras = want_extras, platforms = platforms, python_version = python_version) + _add_req(deps, deps_select, req, extras = want_extras, platforms = platforms) return struct( deps = deps, @@ -190,7 +194,7 @@ def _platform_specializations(self): ]) return specializations -def _add_req(deps, deps_select, req, *, extras, platforms, python_version = None): +def _add_req(deps, deps_select, req, *, extras, platforms): if not req.marker: _add(deps, deps_select, req.name, None) return @@ -215,12 +219,11 @@ def _add_req(deps, deps_select, req, *, extras, platforms, python_version = None if [ True for extra in extras + for p in platforms if evaluate( req.marker, env = env( - target_platform = _platform( - abi = "cp" + python_version.replace("3.", "cp3"), - ), + target_platform = p, extra = extra, ), ) diff --git a/tests/pypi/pep508/deps_tests.bzl b/tests/pypi/pep508/deps_tests.bzl index fc9780b065..99db1e33aa 100644 --- a/tests/pypi/pep508/deps_tests.bzl +++ b/tests/pypi/pep508/deps_tests.bzl @@ -169,6 +169,50 @@ def test_self_is_ignored(env): _tests.append(test_self_is_ignored) +def test_self_dependencies_can_come_in_any_order(env): + got = deps( + "foo", + requires_dist = [ + "bar", + "baz; extra == 'feat'", + "foo[feat2]; extra == 'all'", + "foo[feat]; extra == 'feat2'", + "zdep; extra == 'all'", + ], + extras = ["all"], + python_version = "3.8", + ) + + env.expect.that_collection(got.deps).contains_exactly(["bar", "baz", "zdep"]) + env.expect.that_dict(got.deps_select).contains_exactly({}) + +_tests.append(test_self_dependencies_can_come_in_any_order) + +def _test_can_get_deps_based_on_specific_python_version(env): + requires_dist = [ + "bar", + "baz; python_version < '3.8'", + "posix_dep; os_name=='posix' and python_version >= '3.8'", + ] + + py38 = deps( + "foo", + requires_dist = requires_dist, + platforms = ["cp38_linux_x86_64"], + ) + py37 = deps( + "foo", + requires_dist = requires_dist, + platforms = ["cp37_linux_x86_64"], + ) + + env.expect.that_collection(py37.deps).contains_exactly(["bar", "baz"]) + env.expect.that_dict(py37.deps_select).contains_exactly({}) + env.expect.that_collection(py38.deps).contains_exactly(["bar"]) + env.expect.that_dict(py38.deps_select).contains_exactly({"@platforms//os:linux": ["posix_dep"]}) + +_tests.append(_test_can_get_deps_based_on_specific_python_version) + def deps_test_suite(name): # buildifier: disable=function-docstring test_suite( name = name, @@ -176,50 +220,7 @@ def deps_test_suite(name): # buildifier: disable=function-docstring ) # class DepsTest(unittest.TestCase): -# def test_self_dependencies_can_come_in_any_order(self): -# deps = wheel.Deps( -# "foo", -# requires_dist=[ -# "bar", -# "baz; extra == 'feat'", -# "foo[feat2]; extra == 'all'", -# "foo[feat]; extra == 'feat2'", -# "zdep; extra == 'all'", -# ], -# extras={"all"}, -# ) -# -# got = deps.build() -# -# self.assertEqual(["bar", "baz", "zdep"], got.deps) -# self.assertEqual({}, got.deps_select) -# -# def test_can_get_deps_based_on_specific_python_version(self): -# requires_dist = [ -# "bar", -# "baz; python_version < '3.8'", -# "posix_dep; os_name=='posix' and python_version >= '3.8'", -# ] -# -# py38_deps = wheel.Deps( -# "foo", -# requires_dist=requires_dist, -# platforms=[ -# Platform(os=OS.linux, arch=Arch.x86_64, minor_version=8), -# ], -# ).build() -# py37_deps = wheel.Deps( -# "foo", -# requires_dist=requires_dist, -# platforms=[ -# Platform(os=OS.linux, arch=Arch.x86_64, minor_version=7), -# ], -# ).build() # -# self.assertEqual(["bar", "baz"], py37_deps.deps) -# self.assertEqual({}, py37_deps.deps_select) -# self.assertEqual(["bar"], py38_deps.deps) -# self.assertEqual({"@platforms//os:linux": ["posix_dep"]}, py38_deps.deps_select) # # @mock.patch(_HOST_INTERPRETER_FN) # def test_no_version_select_when_single_version(self, mock_host_interpreter_version): From 8190c3ac9db1ffbe5bb87f8159bf10d377751b3a Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Feb 2025 11:30:28 +0900 Subject: [PATCH 14/65] single version test --- tests/pypi/pep508/deps_tests.bzl | 65 ++++++++++++++------------------ 1 file changed, 29 insertions(+), 36 deletions(-) diff --git a/tests/pypi/pep508/deps_tests.bzl b/tests/pypi/pep508/deps_tests.bzl index 99db1e33aa..9820e6a268 100644 --- a/tests/pypi/pep508/deps_tests.bzl +++ b/tests/pypi/pep508/deps_tests.bzl @@ -213,6 +213,35 @@ def _test_can_get_deps_based_on_specific_python_version(env): _tests.append(_test_can_get_deps_based_on_specific_python_version) +def _test_no_version_select_when_single_version(env): + requires_dist = [ + "bar", + "baz; python_version >= '3.8'", + "posix_dep; os_name=='posix'", + "posix_dep_with_version; os_name=='posix' and python_version >= '3.8'", + "arch_dep; platform_machine=='x86_64' and python_version >= '3.8'", + ] + python_version = "3.7" + + got = deps( + "foo", + requires_dist = requires_dist, + platforms = [ + "cp38_linux_x86_64", + "cp38_windows_x86_64", + ], + python_version = python_version, + ) + + env.expect.that_collection(got.deps).contains_exactly(["bar", "baz"]) + env.expect.that_dict(got.deps_select).contains_exactly({ + "@platforms//os:linux": ["posix_dep", "posix_dep_with_version"], + "linux_x86_64": ["arch_dep", "posix_dep", "posix_dep_with_version"], + "windows_x86_64": ["arch_dep"], + }) + +_tests.append(_test_no_version_select_when_single_version) + def deps_test_suite(name): # buildifier: disable=function-docstring test_suite( name = name, @@ -220,42 +249,6 @@ def deps_test_suite(name): # buildifier: disable=function-docstring ) # class DepsTest(unittest.TestCase): -# -# -# @mock.patch(_HOST_INTERPRETER_FN) -# def test_no_version_select_when_single_version(self, mock_host_interpreter_version): -# requires_dist = [ -# "bar", -# "baz; python_version >= '3.8'", -# "posix_dep; os_name=='posix'", -# "posix_dep_with_version; os_name=='posix' and python_version >= '3.8'", -# "arch_dep; platform_machine=='x86_64' and python_version >= '3.8'", -# ] -# mock_host_interpreter_version.return_value = 7 -# -# self.maxDiff = None -# -# deps = wheel.Deps( -# "foo", -# requires_dist=requires_dist, -# platforms=[ -# Platform(os=os, arch=Arch.x86_64, minor_version=minor) -# for minor in [8] -# for os in [OS.linux, OS.windows] -# ], -# ) -# got = deps.build() -# -# self.assertEqual(["bar", "baz"], got.deps) -# self.assertEqual( -# { -# "@platforms//os:linux": ["posix_dep", "posix_dep_with_version"], -# "linux_x86_64": ["arch_dep", "posix_dep", "posix_dep_with_version"], -# "windows_x86_64": ["arch_dep"], -# }, -# got.deps_select, -# ) -# # @mock.patch(_HOST_INTERPRETER_FN) # def test_can_get_version_select(self, mock_host_interpreter_version): # requires_dist = [ From 82cc18b010e7db1f9fbff2938ab91284d29ddb69 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Feb 2025 11:52:54 +0900 Subject: [PATCH 15/65] one more test is passing --- python/private/pypi/pep508_env.bzl | 51 ++++++++++++++-- tests/pypi/pep508/deps_tests.bzl | 98 +++++++++++++++--------------- 2 files changed, 95 insertions(+), 54 deletions(-) diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 01254d47b7..6b09dd05b4 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -117,9 +117,31 @@ def deps(name, *, requires_dist, platforms = [], extras = [], python_version = N if not platforms and python_version: platforms.append(_platform( abi = "cp" + python_version.replace("3.", "cp3"), + # TODO @aignas 2025-02-23: what to do here? We could + # potentially extract this information from rctx.os + os = None, + arch = None, )) + + abis = sorted({p.abi: True for p in platforms if p.abi}) + if python_version and len(abis) > 1: + default_abi = "cp3" + python_version[2:] + elif len(abis) > 1: + fail( + "all python versions need to be specified explicitly, got: {}".format(platforms), + ) + else: + default_abi = None + for req in reqs: - _add_req(deps, deps_select, req, extras = want_extras, platforms = platforms) + _add_req( + deps, + deps_select, + req, + extras = want_extras, + platforms = platforms, + default_abi = default_abi, + ) return struct( deps = deps, @@ -192,9 +214,15 @@ def _platform_specializations(self): _platform(os = os, arch = self.arch, abi = self.abi) for os in _platform_system_values ]) + if self.os == None and self.arch == None: + specializations.extend([ + _platform(os = os, arch = arch, abi = self.abi) + for os in _platform_system_values + for arch in _platform_machine_values + ]) return specializations -def _add_req(deps, deps_select, req, *, extras, platforms): +def _add_req(deps, deps_select, req, *, extras, platforms, default_abi = None): if not req.marker: _add(deps, deps_select, req.name, None) return @@ -214,8 +242,9 @@ def _add_req(deps, deps_select, req, *, extras, platforms): if tag in req.marker ]) > 0 match_arch = "platform_machine" in req.marker + match_version = "version" in req.marker - if not (match_os or match_arch): + if not (match_os or match_arch or match_version): if [ True for extra in extras @@ -235,10 +264,24 @@ def _add_req(deps, deps_select, req, *, extras, platforms): if not evaluate(req.marker, env = env(plat)): continue - if match_arch: + if match_arch and default_abi: + _add(deps, deps_select, req.name, plat) + if plat.abi == default_abi: + _add(deps, deps_select, req.name, _platform(os = plat.os, arch = plat.arch)) + elif match_arch: _add(deps, deps_select, req.name, _platform(os = plat.os, arch = plat.arch)) + elif match_os and default_abi: + _add(deps, deps_select, req.name, _platform(os = plat.os, abi = plat.abi)) + if plat.abi == default_abi: + _add(deps, deps_select, req.name, _platform(os = plat.os)) elif match_os: _add(deps, deps_select, req.name, _platform(os = plat.os)) + elif match_version and default_abi: + _add(deps, deps_select, req.name, _platform(abi = plat.abi)) + if plat.abi == default_abi: + _add(deps, deps_select, req.name, _platform()) + elif match_version: + _add(deps, deps_select, req.name, None) else: fail("TODO: {}, {}".format(req.marker, plat)) diff --git a/tests/pypi/pep508/deps_tests.bzl b/tests/pypi/pep508/deps_tests.bzl index 9820e6a268..53e45d8585 100644 --- a/tests/pypi/pep508/deps_tests.bzl +++ b/tests/pypi/pep508/deps_tests.bzl @@ -242,6 +242,54 @@ def _test_no_version_select_when_single_version(env): _tests.append(_test_no_version_select_when_single_version) +def _test_can_get_version_select(env): + requires_dist = [ + "bar", + "baz; python_version < '3.8'", + "baz_new; python_version >= '3.8'", + "posix_dep; os_name=='posix'", + "posix_dep_with_version; os_name=='posix' and python_version >= '3.8'", + "arch_dep; platform_machine=='x86_64' and python_version < '3.8'", + ] + python_version = "3.7" + + got = deps( + "foo", + requires_dist = requires_dist, + platforms = [ + "cp3{}_{}_x86_64".format(minor, os) + for minor in [7, 8, 9] + for os in ["linux", "windows"] + ], + python_version = python_version, + ) + + env.expect.that_collection(got.deps).contains_exactly(["bar"]) + env.expect.that_dict(got.deps_select).contains_exactly({ + "@//python/config_settings:is_python_3.7": ["baz"], + "@//python/config_settings:is_python_3.8": ["baz_new"], + "@//python/config_settings:is_python_3.9": ["baz_new"], + "@platforms//os:linux": ["baz", "posix_dep"], + "cp37_linux_anyarch": ["baz", "posix_dep"], + "cp37_linux_x86_64": ["arch_dep", "baz", "posix_dep"], + "cp37_windows_x86_64": ["arch_dep", "baz"], + "cp38_linux_anyarch": [ + "baz_new", + "posix_dep", + "posix_dep_with_version", + ], + "cp39_linux_anyarch": [ + "baz_new", + "posix_dep", + "posix_dep_with_version", + ], + "linux_x86_64": ["arch_dep", "baz", "posix_dep"], + "windows_x86_64": ["arch_dep", "baz"], + "//conditions:default": ["baz"], + }) + +_tests.append(_test_can_get_version_select) + def deps_test_suite(name): # buildifier: disable=function-docstring test_suite( name = name, @@ -250,56 +298,6 @@ def deps_test_suite(name): # buildifier: disable=function-docstring # class DepsTest(unittest.TestCase): # @mock.patch(_HOST_INTERPRETER_FN) -# def test_can_get_version_select(self, mock_host_interpreter_version): -# requires_dist = [ -# "bar", -# "baz; python_version < '3.8'", -# "baz_new; python_version >= '3.8'", -# "posix_dep; os_name=='posix'", -# "posix_dep_with_version; os_name=='posix' and python_version >= '3.8'", -# "arch_dep; platform_machine=='x86_64' and python_version < '3.8'", -# ] -# mock_host_interpreter_version.return_value = 7 -# -# self.maxDiff = None -# -# deps = wheel.Deps( -# "foo", -# requires_dist=requires_dist, -# platforms=[ -# Platform(os=os, arch=Arch.x86_64, minor_version=minor) -# for minor in [7, 8, 9] -# for os in [OS.linux, OS.windows] -# ], -# ) -# got = deps.build() -# -# self.assertEqual(["bar"], got.deps) -# self.assertEqual( -# { -# "//conditions:default": ["baz"], -# "@//python/config_settings:is_python_3.7": ["baz"], -# "@//python/config_settings:is_python_3.8": ["baz_new"], -# "@//python/config_settings:is_python_3.9": ["baz_new"], -# "@platforms//os:linux": ["baz", "posix_dep"], -# "cp37_linux_x86_64": ["arch_dep", "baz", "posix_dep"], -# "cp37_windows_x86_64": ["arch_dep", "baz"], -# "cp37_linux_anyarch": ["baz", "posix_dep"], -# "cp38_linux_anyarch": [ -# "baz_new", -# "posix_dep", -# "posix_dep_with_version", -# ], -# "cp39_linux_anyarch": [ -# "baz_new", -# "posix_dep", -# "posix_dep_with_version", -# ], -# "linux_x86_64": ["arch_dep", "baz", "posix_dep"], -# "windows_x86_64": ["arch_dep", "baz"], -# }, -# got.deps_select, -# ) # # @mock.patch(_HOST_INTERPRETER_FN) # def test_deps_spanning_all_target_py_versions_are_added_to_common( From e26232c1069b5e73208e9f62b2b13761e4c49d45 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Feb 2025 12:00:37 +0900 Subject: [PATCH 16/65] simplifying of deps --- python/private/pypi/pep508_env.bzl | 60 +++++++++++++++++------------- tests/pypi/pep508/deps_tests.bzl | 45 +++++++++++----------- 2 files changed, 57 insertions(+), 48 deletions(-) diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 6b09dd05b4..31be1aac76 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -163,9 +163,11 @@ def _versioned_platform(os_arch, python_version): def _req(requires_dist): requires, _, marker = requires_dist.partition(";") requires, _, extras_unparsed = requires.partition("[") + requires, _, _ = requires.partition("(") + requires, _, _ = requires.partition(" ") extras = extras_unparsed.strip("]").split(",") return struct( - name = normalize_name(requires), + name = normalize_name(requires.strip(" ")), marker = marker.strip(" "), extras = extras, ) @@ -285,6 +287,8 @@ def _add_req(deps, deps_select, req, *, extras, platforms, default_abi = None): else: fail("TODO: {}, {}".format(req.marker, plat)) + _maybe_add_common_dep(deps, deps_select, platforms, req.name) + def _add(deps, deps_select, dep, platform): dep = normalize_name(dep) add_to = [] @@ -376,6 +380,35 @@ def _resolve_extras(self_name, reqs, extras): # Poor mans set return sorted({x: None for x in extras}) +def _maybe_add_common_dep(deps, deps_select, platforms, dep): + abis = sorted({p.abi: True for p in platforms if p.abi}) + if len(abis) < 2: + return + + platforms = [_platform()] + [ + _platform(abi = abi) + for abi in abis + ] + + # If the dep is targeting all target python versions, lets add it to + # the common dependency list to simplify the select statements. + for p in platforms: + if p not in deps_select: + return + + if dep not in deps_select[p]: + return + + # All of the python version-specific branches have the dep, so lets add + # it to the common deps. + deps.append(dep) + for p in platforms: + deps_select[p].remove(dep) + if not deps_select[p]: + deps_select.pop(p) + +# ================ + # if not self._platforms: # if any(req.marker.evaluate({"extra": extra}) for extra in extras): # self._add(req.name, None) @@ -513,31 +546,6 @@ def _resolve_extras(self_name, reqs, extras): # self._select[platform].update(self._select[p]) -# def _maybe_add_common_dep(self, dep): -# if len(self._target_versions) < 2: -# return - -# platforms = [Platform()] + [ -# Platform(minor_version=v) for v in self._target_versions -# ] - -# # If the dep is targeting all target python versions, lets add it to -# # the common dependency list to simplify the select statements. -# for p in platforms: -# if p not in self._select: -# return - -# if dep not in self._select[p]: -# return - -# # All of the python version-specific branches have the dep, so lets add -# # it to the common deps. -# self._deps.add(dep) -# for p in platforms: -# self._select[p].remove(dep) -# if not self._select[p]: -# self._select.pop(p) - # def _resolve_extras( # self, reqs: List[Requirement], extras: Optional[Set[str]] # ) -> Set[str]: diff --git a/tests/pypi/pep508/deps_tests.bzl b/tests/pypi/pep508/deps_tests.bzl index 53e45d8585..58a36a5727 100644 --- a/tests/pypi/pep508/deps_tests.bzl +++ b/tests/pypi/pep508/deps_tests.bzl @@ -290,6 +290,29 @@ def _test_can_get_version_select(env): _tests.append(_test_can_get_version_select) +def _test_deps_spanning_all_target_py_versions_are_added_to_common(env): + requires_dist = [ + "bar", + "baz (<2,>=1.11) ; python_version < '3.8'", + "baz (<2,>=1.14) ; python_version >= '3.8'", + ] + python_version = "3.8" + + got = deps( + "foo", + requires_dist = requires_dist, + platforms = [ + "cp3{}_linux_x86_64".format(minor) + for minor in [7, 8, 9] + ], + python_version = python_version, + ) + + env.expect.that_collection(got.deps).contains_exactly(["bar", "baz"]) + env.expect.that_dict(got.deps_select).contains_exactly({}) + +_tests.append(_test_deps_spanning_all_target_py_versions_are_added_to_common) + def deps_test_suite(name): # buildifier: disable=function-docstring test_suite( name = name, @@ -297,28 +320,6 @@ def deps_test_suite(name): # buildifier: disable=function-docstring ) # class DepsTest(unittest.TestCase): -# @mock.patch(_HOST_INTERPRETER_FN) -# -# @mock.patch(_HOST_INTERPRETER_FN) -# def test_deps_spanning_all_target_py_versions_are_added_to_common( -# self, mock_host_version -# ): -# requires_dist = [ -# "bar", -# "baz (<2,>=1.11) ; python_version < '3.8'", -# "baz (<2,>=1.14) ; python_version >= '3.8'", -# ] -# mock_host_version.return_value = 8 -# -# deps = wheel.Deps( -# "foo", -# requires_dist=requires_dist, -# platforms=Platform.from_string(["cp37_*", "cp38_*", "cp39_*"]), -# ) -# got = deps.build() -# -# self.assertEqual(["bar", "baz"], got.deps) -# self.assertEqual({}, got.deps_select) # # @mock.patch(_HOST_INTERPRETER_FN) # def test_deps_are_not_duplicated(self, mock_host_version): From 31161db32b4fc9b4b8f753276f0802c500720160 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Feb 2025 12:26:41 +0900 Subject: [PATCH 17/65] wip --- python/private/pypi/pep508_env.bzl | 58 ++++++++++++++++------------- tests/pypi/pep508/deps_tests.bzl | 60 ++++++++++++++++-------------- 2 files changed, 66 insertions(+), 52 deletions(-) diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 31be1aac76..3c2df5c29f 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -101,7 +101,7 @@ def deps(name, *, requires_dist, platforms = [], extras = [], python_version = N [_req(r) for r in requires_dist], key = lambda x: x.name, ) - deps = [] + deps = {} deps_select = {} name = normalize_name(name) @@ -111,7 +111,7 @@ def deps(name, *, requires_dist, platforms = [], extras = [], python_version = N reqs = [r for r in reqs if r.name != name] platforms = [ - _platform_from_str(_versioned_platform(p, python_version)) + _platform_from_str(p, python_version) for p in platforms ] if not platforms and python_version: @@ -144,22 +144,13 @@ def deps(name, *, requires_dist, platforms = [], extras = [], python_version = N ) return struct( - deps = deps, + deps = sorted(deps), deps_select = { - _platform_str(p): deps + _platform_str(p): sorted(deps) for p, deps in deps_select.items() }, ) -def _versioned_platform(os_arch, python_version): - if not python_version or os_arch.startswith("cp"): - # This also has ABI - return os_arch - - major, _, tail = python_version.partition(".") - minor, _, _ = tail.partition(".") - return "cp{}{}_{}".format(major, minor, os_arch) - def _req(requires_dist): requires, _, marker = requires_dist.partition(";") requires, _, extras_unparsed = requires.partition("[") @@ -179,8 +170,13 @@ def _platform(*, abi = None, os = None, arch = None): arch = arch, ) -def _platform_from_str(p): - abi, _, p = p.partition("_") +def _platform_from_str(p, python_version): + if p.startswith("cp"): + abi, _, p = p.partition("_") + else: + major, _, tail = python_version.partition(".") + abi = "cp{}{}".format(major, tail) + os, _, arch = p.partition("_") return _platform(abi = abi, os = os, arch = arch) @@ -293,9 +289,26 @@ def _add(deps, deps_select, dep, platform): dep = normalize_name(dep) add_to = [] + if not platform: + deps[dep] = True + + # If the dep is in the platform-specific list, remove it from the select. + pop_keys = [] + for p, _deps in deps_select.items(): + if dep not in _deps: + continue + + _deps.pop(dep) + if not _deps: + pop_keys.append(p) + + for p in pop_keys: + deps_select.pop(p) + return + if platform: # Add the platform-specific dep - deps = deps_select.setdefault(platform, []) + deps = deps_select.setdefault(platform, {}) add_to.append(deps) if not deps: # We are adding a new item to the select and we need to ensure that @@ -307,9 +320,7 @@ def _add(deps, deps_select, dep, platform): continue # Copy existing elements from the existing specializations. - for d in existing_deps: - if d not in deps: - deps.append(d) + deps.update(existing_deps) for p in _platform_specializations(platform): if p not in deps_select: @@ -318,12 +329,9 @@ def _add(deps, deps_select, dep, platform): more_specialized_deps = deps_select.get(p, []) if dep not in more_specialized_deps: add_to.append(more_specialized_deps) - else: - add_to.append(deps) for deps in add_to: - if dep not in deps: - deps.append(dep) + deps[dep] = True def _resolve_extras(self_name, reqs, extras): """Resolve extras which are due to depending on self[some_other_extra]. @@ -401,9 +409,9 @@ def _maybe_add_common_dep(deps, deps_select, platforms, dep): # All of the python version-specific branches have the dep, so lets add # it to the common deps. - deps.append(dep) + deps[dep] = True for p in platforms: - deps_select[p].remove(dep) + deps_select[p].pop(dep) if not deps_select[p]: deps_select.pop(p) diff --git a/tests/pypi/pep508/deps_tests.bzl b/tests/pypi/pep508/deps_tests.bzl index 58a36a5727..d9c66dedee 100644 --- a/tests/pypi/pep508/deps_tests.bzl +++ b/tests/pypi/pep508/deps_tests.bzl @@ -313,6 +313,39 @@ def _test_deps_spanning_all_target_py_versions_are_added_to_common(env): _tests.append(_test_deps_spanning_all_target_py_versions_are_added_to_common) +def _test_deps_are_not_duplicated(env): + python_version = "3.7" + + # See an example in + # https://files.pythonhosted.org/packages/76/9e/db1c2d56c04b97981c06663384f45f28950a73d9acf840c4006d60d0a1ff/opencv_python-4.9.0.80-cp37-abi3-win32.whl.metadata + requires_dist = [ + "bar >=0.1.0 ; python_version < '3.7'", + "bar >=0.2.0 ; python_version >= '3.7'", + "bar >=0.4.0 ; python_version >= '3.6' and platform_system == 'Linux' and platform_machine == 'aarch64'", + "bar >=0.4.0 ; python_version >= '3.9'", + "bar >=0.5.0 ; python_version <= '3.9' and platform_system == 'Darwin' and platform_machine == 'arm64'", + "bar >=0.5.0 ; python_version >= '3.10' and platform_system == 'Darwin'", + "bar >=0.5.0 ; python_version >= '3.10'", + "bar >=0.6.0 ; python_version >= '3.11'", + ] + + got = deps( + "foo", + requires_dist = requires_dist, + platforms = [ + "cp3{}_{}_{}".format(minor, os, arch) + for minor in [7, 10] + for os in ["linux", "osx", "windows"] + for arch in ["x86_64", "aarch64"] + ], + python_version = python_version, + ) + + env.expect.that_collection(got.deps).contains_exactly(["bar"]) + env.expect.that_dict(got.deps_select).contains_exactly({}) + +_tests.append(_test_deps_are_not_duplicated) + def deps_test_suite(name): # buildifier: disable=function-docstring test_suite( name = name, @@ -322,33 +355,6 @@ def deps_test_suite(name): # buildifier: disable=function-docstring # class DepsTest(unittest.TestCase): # # @mock.patch(_HOST_INTERPRETER_FN) -# def test_deps_are_not_duplicated(self, mock_host_version): -# mock_host_version.return_value = 7 -# -# # See an example in -# # https://files.pythonhosted.org/packages/76/9e/db1c2d56c04b97981c06663384f45f28950a73d9acf840c4006d60d0a1ff/opencv_python-4.9.0.80-cp37-abi3-win32.whl.metadata -# requires_dist = [ -# "bar >=0.1.0 ; python_version < '3.7'", -# "bar >=0.2.0 ; python_version >= '3.7'", -# "bar >=0.4.0 ; python_version >= '3.6' and platform_system == 'Linux' and platform_machine == 'aarch64'", -# "bar >=0.4.0 ; python_version >= '3.9'", -# "bar >=0.5.0 ; python_version <= '3.9' and platform_system == 'Darwin' and platform_machine == 'arm64'", -# "bar >=0.5.0 ; python_version >= '3.10' and platform_system == 'Darwin'", -# "bar >=0.5.0 ; python_version >= '3.10'", -# "bar >=0.6.0 ; python_version >= '3.11'", -# ] -# -# deps = wheel.Deps( -# "foo", -# requires_dist=requires_dist, -# platforms=Platform.from_string(["cp37_*", "cp310_*"]), -# ) -# got = deps.build() -# -# self.assertEqual(["bar"], got.deps) -# self.assertEqual({}, got.deps_select) -# -# @mock.patch(_HOST_INTERPRETER_FN) # def test_deps_are_not_duplicated_when_encountering_platform_dep_first( # self, mock_host_version # ): From 0a191ae1604099f69143b968be946d2b2d012f65 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Feb 2025 12:54:15 +0900 Subject: [PATCH 18/65] fix the impl --- python/private/pypi/pep508_env.bzl | 69 ++++++++++++++---------------- tests/pypi/pep508/deps_tests.bzl | 29 +++++++------ 2 files changed, 46 insertions(+), 52 deletions(-) diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 3c2df5c29f..391f6eedd1 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -80,7 +80,7 @@ def env(target_platform, *, extra = None): "python_version": "3.{}".format(minor), } | extras -def deps(name, *, requires_dist, platforms = [], extras = [], python_version = None): +def deps(name, *, requires_dist, platforms = [], extras = [], host_python_version = None): """Parse the RequiresDist from wheel METADATA Args: @@ -89,7 +89,7 @@ def deps(name, *, requires_dist, platforms = [], extras = [], python_version = N METADATA file. extras: {type}`list[str]` the requested extras to generate targets for. platforms: {type}`list[str]` the list of target platform strings. - python_version: {type}`str` the host python version. + host_python_version: {type}`str` the host python version. Will be removed. Returns: A struct with attributes: @@ -110,22 +110,16 @@ def deps(name, *, requires_dist, platforms = [], extras = [], python_version = N # drop self edges reqs = [r for r in reqs if r.name != name] + if not platforms: + fail("The platform needs to be specified") platforms = [ - _platform_from_str(p, python_version) + _platform_from_str(p, python_version = host_python_version) for p in platforms ] - if not platforms and python_version: - platforms.append(_platform( - abi = "cp" + python_version.replace("3.", "cp3"), - # TODO @aignas 2025-02-23: what to do here? We could - # potentially extract this information from rctx.os - os = None, - arch = None, - )) abis = sorted({p.abi: True for p in platforms if p.abi}) - if python_version and len(abis) > 1: - default_abi = "cp3" + python_version[2:] + if host_python_version and len(abis) > 1: + default_abi = "cp3" + host_python_version[2:].partition(".")[0] elif len(abis) > 1: fail( "all python versions need to be specified explicitly, got: {}".format(platforms), @@ -287,7 +281,6 @@ def _add_req(deps, deps_select, req, *, extras, platforms, default_abi = None): def _add(deps, deps_select, dep, platform): dep = normalize_name(dep) - add_to = [] if not platform: deps[dep] = True @@ -306,32 +299,32 @@ def _add(deps, deps_select, dep, platform): deps_select.pop(p) return - if platform: - # Add the platform-specific dep - deps = deps_select.setdefault(platform, {}) - add_to.append(deps) - if not deps: - # We are adding a new item to the select and we need to ensure that - # existing dependencies from less specialized platforms are propagated - # to the newly added dependency set. - for p, existing_deps in deps_select.items(): - # Check if the existing platform overlaps with the given platform - if p == platform or platform not in _platform_specializations(p): - continue - - # Copy existing elements from the existing specializations. - deps.update(existing_deps) - - for p in _platform_specializations(platform): - if p not in deps_select: - continue + if dep in deps: + # If the dep is already in the main dependency list, no need to add it in the + # platform-specific dependency list. + return - more_specialized_deps = deps_select.get(p, []) - if dep not in more_specialized_deps: - add_to.append(more_specialized_deps) + # Add the platform-specific dep + deps_select.setdefault(platform, {})[dep] = True - for deps in add_to: - deps[dep] = True + # Add the dep to specializations of the given platform if they + # exist in the select statement. + for p in _platform_specializations(platform): + if p not in deps_select: + continue + + deps_select[p][dep] = True + + if len(deps_select[platform]) == 1: + # We are adding a new item to the select and we need to ensure that + # existing dependencies from less specialized platforms are propagated + # to the newly added dependency set. + for p, deps in deps_select.items(): + # Check if the existing platform overlaps with the given platform + if p == platform or platform not in _platform_specializations(p): + continue + + deps_select[platform].update(deps_select[p]) def _resolve_extras(self_name, reqs, extras): """Resolve extras which are due to depending on self[some_other_extra]. diff --git a/tests/pypi/pep508/deps_tests.bzl b/tests/pypi/pep508/deps_tests.bzl index d9c66dedee..abd36a8106 100644 --- a/tests/pypi/pep508/deps_tests.bzl +++ b/tests/pypi/pep508/deps_tests.bzl @@ -22,6 +22,7 @@ def test_simple_deps(env): got = deps( "foo", requires_dist = ["bar-Bar"], + platforms = ["cp38_linux_x86_64"], ) env.expect.that_collection(got.deps).contains_exactly(["bar_bar"]) env.expect.that_dict(got.deps_select).contains_exactly({}) @@ -43,7 +44,7 @@ def test_can_add_os_specific_deps(env): "osx_aarch64", "windows_x86_64", ], - python_version = "3.3.1", + host_python_version = "3.3.1", ) env.expect.that_collection(got.deps).contains_exactly(["bar"]) @@ -92,7 +93,7 @@ def test_deps_are_added_to_more_specialized_platforms(env): "osx_x86_64", "osx_aarch64", ], - python_version = "3.8", + host_python_version = "3.8.4", ) env.expect.that_collection(got.deps).contains_exactly([]) @@ -114,7 +115,7 @@ def test_deps_from_more_specialized_platforms_are_propagated(env): "osx_x86_64", "osx_aarch64", ], - python_version = "3.8", + host_python_version = "3.8.4", ) env.expect.that_collection(got.deps).contains_exactly([]) @@ -141,7 +142,7 @@ def test_non_platform_markers_are_added_to_common_deps(env): "osx_aarch64", "windows_x86_64", ], - python_version = "3.8", + host_python_version = "3.8.4", ) env.expect.that_collection(got.deps).contains_exactly(["bar", "baz"]) @@ -161,7 +162,7 @@ def test_self_is_ignored(env): "ssl_lib; extra == 'ssl'", ], extras = ["ssl"], - python_version = "3.8", + platforms = ["cp38_linux_x86_64"], ) env.expect.that_collection(got.deps).contains_exactly(["bar", "req_dep", "ssl_lib"]) @@ -180,7 +181,7 @@ def test_self_dependencies_can_come_in_any_order(env): "zdep; extra == 'all'", ], extras = ["all"], - python_version = "3.8", + platforms = ["cp38_linux_x86_64"], ) env.expect.that_collection(got.deps).contains_exactly(["bar", "baz", "zdep"]) @@ -221,7 +222,7 @@ def _test_no_version_select_when_single_version(env): "posix_dep_with_version; os_name=='posix' and python_version >= '3.8'", "arch_dep; platform_machine=='x86_64' and python_version >= '3.8'", ] - python_version = "3.7" + host_python_version = "3.7.5" got = deps( "foo", @@ -230,7 +231,7 @@ def _test_no_version_select_when_single_version(env): "cp38_linux_x86_64", "cp38_windows_x86_64", ], - python_version = python_version, + host_python_version = host_python_version, ) env.expect.that_collection(got.deps).contains_exactly(["bar", "baz"]) @@ -251,7 +252,7 @@ def _test_can_get_version_select(env): "posix_dep_with_version; os_name=='posix' and python_version >= '3.8'", "arch_dep; platform_machine=='x86_64' and python_version < '3.8'", ] - python_version = "3.7" + host_python_version = "3.7.4" got = deps( "foo", @@ -261,7 +262,7 @@ def _test_can_get_version_select(env): for minor in [7, 8, 9] for os in ["linux", "windows"] ], - python_version = python_version, + host_python_version = host_python_version, ) env.expect.that_collection(got.deps).contains_exactly(["bar"]) @@ -296,7 +297,7 @@ def _test_deps_spanning_all_target_py_versions_are_added_to_common(env): "baz (<2,>=1.11) ; python_version < '3.8'", "baz (<2,>=1.14) ; python_version >= '3.8'", ] - python_version = "3.8" + host_python_version = "3.8.4" got = deps( "foo", @@ -305,7 +306,7 @@ def _test_deps_spanning_all_target_py_versions_are_added_to_common(env): "cp3{}_linux_x86_64".format(minor) for minor in [7, 8, 9] ], - python_version = python_version, + host_python_version = host_python_version, ) env.expect.that_collection(got.deps).contains_exactly(["bar", "baz"]) @@ -314,7 +315,7 @@ def _test_deps_spanning_all_target_py_versions_are_added_to_common(env): _tests.append(_test_deps_spanning_all_target_py_versions_are_added_to_common) def _test_deps_are_not_duplicated(env): - python_version = "3.7" + host_python_version = "3.7.4" # See an example in # https://files.pythonhosted.org/packages/76/9e/db1c2d56c04b97981c06663384f45f28950a73d9acf840c4006d60d0a1ff/opencv_python-4.9.0.80-cp37-abi3-win32.whl.metadata @@ -338,7 +339,7 @@ def _test_deps_are_not_duplicated(env): for os in ["linux", "osx", "windows"] for arch in ["x86_64", "aarch64"] ], - python_version = python_version, + host_python_version = host_python_version, ) env.expect.that_collection(got.deps).contains_exactly(["bar"]) From 973ff068fd17bd93146f9ff9f82a891cc85ce6af Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Feb 2025 12:58:10 +0900 Subject: [PATCH 19/65] last test passes --- tests/pypi/pep508/deps_tests.bzl | 52 +++++++++++++++++--------------- 1 file changed, 27 insertions(+), 25 deletions(-) diff --git a/tests/pypi/pep508/deps_tests.bzl b/tests/pypi/pep508/deps_tests.bzl index abd36a8106..8f144cf0a3 100644 --- a/tests/pypi/pep508/deps_tests.bzl +++ b/tests/pypi/pep508/deps_tests.bzl @@ -347,33 +347,35 @@ def _test_deps_are_not_duplicated(env): _tests.append(_test_deps_are_not_duplicated) +def _test_deps_are_not_duplicated_when_encountering_platform_dep_first(env): + host_python_version = "3.7.1" + + # Note, that we are sorting the incoming `requires_dist` and we need to ensure that we are not getting any + # issues even if the platform-specific line comes first. + requires_dist = [ + "bar >=0.4.0 ; python_version >= '3.6' and platform_system == 'Linux' and platform_machine == 'aarch64'", + "bar >=0.5.0 ; python_version >= '3.9'", + ] + + got = deps( + "foo", + requires_dist = requires_dist, + platforms = [ + "cp37_linux_aarch64", + "cp37_linux_x86_64", + "cp310_linux_aarch64", + "cp310_linux_x86_64", + ], + host_python_version = host_python_version, + ) + + env.expect.that_collection(got.deps).contains_exactly(["bar"]) + env.expect.that_dict(got.deps_select).contains_exactly({}) + +_tests.append(_test_deps_are_not_duplicated_when_encountering_platform_dep_first) + def deps_test_suite(name): # buildifier: disable=function-docstring test_suite( name = name, basic_tests = _tests, ) - -# class DepsTest(unittest.TestCase): -# -# @mock.patch(_HOST_INTERPRETER_FN) -# def test_deps_are_not_duplicated_when_encountering_platform_dep_first( -# self, mock_host_version -# ): -# mock_host_version.return_value = 7 -# -# # Note, that we are sorting the incoming `requires_dist` and we need to ensure that we are not getting any -# # issues even if the platform-specific line comes first. -# requires_dist = [ -# "bar >=0.4.0 ; python_version >= '3.6' and platform_system == 'Linux' and platform_machine == 'aarch64'", -# "bar >=0.5.0 ; python_version >= '3.9'", -# ] -# -# deps = wheel.Deps( -# "foo", -# requires_dist=requires_dist, -# platforms=Platform.from_string(["cp37_*", "cp310_*"]), -# ) -# got = deps.build() -# -# self.assertEqual(["bar"], got.deps) -# self.assertEqual({}, got.deps_select) From df604142a598ec8caf6a48cfa38c7e7739b56a17 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Feb 2025 13:00:19 +0900 Subject: [PATCH 20/65] upgrade the copyright --- python/private/pypi/pep508.bzl | 2 +- python/private/pypi/pep508_env.bzl | 2 +- python/private/pypi/pep508_evaluate.bzl | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/python/private/pypi/pep508.bzl b/python/private/pypi/pep508.bzl index 92cf61bb74..e74352def2 100644 --- a/python/private/pypi/pep508.bzl +++ b/python/private/pypi/pep508.bzl @@ -1,4 +1,4 @@ -# Copyright 2024 The Bazel Authors. All rights reserved. +# Copyright 2025 The Bazel Authors. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 391f6eedd1..cc65d4ccb0 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -1,4 +1,4 @@ -# Copyright 2024 The Bazel Authors. All rights reserved. +# Copyright 2025 The Bazel Authors. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/python/private/pypi/pep508_evaluate.bzl b/python/private/pypi/pep508_evaluate.bzl index 1226ab6532..6703b3fcd0 100644 --- a/python/private/pypi/pep508_evaluate.bzl +++ b/python/private/pypi/pep508_evaluate.bzl @@ -1,4 +1,4 @@ -# Copyright 2024 The Bazel Authors. All rights reserved. +# Copyright 2025 The Bazel Authors. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. From d3a46d69b06c53a4ccfaab05a94371ab4ff96bb4 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Feb 2025 13:04:04 +0900 Subject: [PATCH 21/65] wip --- python/private/pypi/pep508_env.bzl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index cc65d4ccb0..24a516519c 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -89,7 +89,7 @@ def deps(name, *, requires_dist, platforms = [], extras = [], host_python_versio METADATA file. extras: {type}`list[str]` the requested extras to generate targets for. platforms: {type}`list[str]` the list of target platform strings. - host_python_version: {type}`str` the host python version. Will be removed. + host_python_version: {type}`str` the host python version. Returns: A struct with attributes: From 5fbd827b49b0e176a8b0e3e804fe99776751c9da Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Feb 2025 13:37:31 +0900 Subject: [PATCH 22/65] wip --- python/private/pypi/pep508_env.bzl | 337 +++-------------------------- python/private/pypi/pep508_req.bzl | 38 ++++ tests/pypi/pep508/deps_tests.bzl | 3 - 3 files changed, 71 insertions(+), 307 deletions(-) create mode 100644 python/private/pypi/pep508_req.bzl diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 24a516519c..8e7854d493 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -17,6 +17,7 @@ load("//python/private:normalize_name.bzl", "normalize_name") load(":pep508_evaluate.bzl", "evaluate") +load(":pep508_req.bzl", _req = "requirement") _platform_machine_values = { "aarch64": "arm64", @@ -53,32 +54,35 @@ def env(target_platform, *, extra = None): A dict that can be used as `env` in the marker evaluation. """ - # TODO @aignas 2024-12-26: wire up the usage of the micro version - minor, _, micro = target_platform.abi[3:].partition(".") - micro = micro or "0" - os = target_platform.os - arch = target_platform.arch - # TODO @aignas 2025-02-13: consider moving this into config settings. - extras = {"extra": extra} if extra != None else {} - - # This is split by topic - return { - "os_name": _os_name_values.get(os, ""), - "platform_machine": "aarch64" if (os, arch) == ("linux", "aarch64") else _platform_machine_values.get(arch, ""), - "platform_system": _platform_system_values.get(os, ""), - "sys_platform": _sys_platform_values.get(os, ""), - } | { + env = {"extra": extra} if extra != None else {} + env = env | { "implementation_name": "cpython", "platform_python_implementation": "CPython", "platform_release": "", "platform_version": "", - } | { - "implementation_version": "3.{}.{}".format(minor, micro), - "python_full_version": "3.{}.{}".format(minor, micro), - "python_version": "3.{}".format(minor), - } | extras + } + if target_platform.abi: + minor_version, _, micro_version = target_platform.abi[3:].partition(".") + micro_version = micro_version or "0" + 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), + } + if target_platform.os and target_platform.arch: + os = target_platform.os + arch = target_platform.arch + env = env | { + "os_name": _os_name_values.get(os, ""), + "platform_machine": "aarch64" if (os, arch) == ("linux", "aarch64") else _platform_machine_values.get(arch, ""), + "platform_system": _platform_system_values.get(os, ""), + "sys_platform": _sys_platform_values.get(os, ""), + } + + # This is split by topic + return env def deps(name, *, requires_dist, platforms = [], extras = [], host_python_version = None): """Parse the RequiresDist from wheel METADATA @@ -104,17 +108,16 @@ def deps(name, *, requires_dist, platforms = [], extras = [], host_python_versio deps = {} deps_select = {} name = normalize_name(name) - want_extras = _resolve_extras(name, reqs, extras) # drop self edges reqs = [r for r in reqs if r.name != name] - if not platforms: - fail("The platform needs to be specified") platforms = [ _platform_from_str(p, python_version = host_python_version) for p in platforms + ] or [ + _platform_from_str("", python_version = host_python_version), ] abis = sorted({p.abi: True for p in platforms if p.abi}) @@ -145,18 +148,6 @@ def deps(name, *, requires_dist, platforms = [], extras = [], host_python_versio }, ) -def _req(requires_dist): - requires, _, marker = requires_dist.partition(";") - requires, _, extras_unparsed = requires.partition("[") - requires, _, _ = requires.partition("(") - requires, _, _ = requires.partition(" ") - extras = extras_unparsed.strip("]").split(",") - return struct( - name = normalize_name(requires.strip(" ")), - marker = marker.strip(" "), - extras = extras, - ) - def _platform(*, abi = None, os = None, arch = None): return struct( abi = abi, @@ -167,12 +158,14 @@ def _platform(*, abi = None, os = None, arch = None): def _platform_from_str(p, python_version): if p.startswith("cp"): abi, _, p = p.partition("_") - else: + elif python_version: major, _, tail = python_version.partition(".") abi = "cp{}{}".format(major, tail) + else: + abi = None os, _, arch = p.partition("_") - return _platform(abi = abi, os = os, arch = arch) + return _platform(abi = abi, os = os or None, arch = arch or None) def _platform_str(self): if self.abi == None: @@ -275,13 +268,11 @@ def _add_req(deps, deps_select, req, *, extras, platforms, default_abi = None): elif match_version: _add(deps, deps_select, req.name, None) else: - fail("TODO: {}, {}".format(req.marker, plat)) + fail("BUG: {} support is not implemented".format(req.marker)) _maybe_add_common_dep(deps, deps_select, platforms, req.name) def _add(deps, deps_select, dep, platform): - dep = normalize_name(dep) - if not platform: deps[dep] = True @@ -324,7 +315,7 @@ def _add(deps, deps_select, dep, platform): if p == platform or platform not in _platform_specializations(p): continue - deps_select[platform].update(deps_select[p]) + deps_select[platform].update(deps) def _resolve_extras(self_name, reqs, extras): """Resolve extras which are due to depending on self[some_other_extra]. @@ -351,7 +342,7 @@ def _resolve_extras(self_name, reqs, extras): self_reqs = [] for req in reqs: - if normalize_name(req.name) != self_name: + if req.name != self_name: continue if req.marker == None: @@ -407,265 +398,3 @@ def _maybe_add_common_dep(deps, deps_select, platforms, dep): deps_select[p].pop(dep) if not deps_select[p]: deps_select.pop(p) - -# ================ - -# if not self._platforms: -# if any(req.marker.evaluate({"extra": extra}) for extra in extras): -# self._add(req.name, None) -# return - -# # NOTE @aignas 2023-12-08: in order to have reasonable select statements -# # we do have to have some parsing of the markers, so it begs the question -# # if packaging should be reimplemented in Starlark to have the best solution -# # for now we will implement it in Python and see what the best parsing result -# # can be before making this decision. -# match_os = any( -# tag in marker_str -# for tag in [ -# "os_name", -# "sys_platform", -# "platform_system", -# ] -# ) -# match_arch = "platform_machine" in marker_str -# match_version = "version" in marker_str - -# if not (match_os or match_arch or match_version): -# if any(req.marker.evaluate({"extra": extra}) for extra in extras): -# self._add(req.name, None) -# return - -# for plat in self._platforms: -# if not any( -# req.marker.evaluate(plat.env_markers(extra)) for extra in extras -# ): -# continue - -# if match_arch and self._default_minor_version: -# self._add(req.name, plat) -# if plat.minor_version == self._default_minor_version: -# self._add(req.name, Platform(plat.os, plat.arch)) -# elif match_arch: -# self._add(req.name, Platform(plat.os, plat.arch)) -# elif match_os and self._default_minor_version: -# self._add(req.name, Platform(plat.os, minor_version=plat.minor_version)) -# if plat.minor_version == self._default_minor_version: -# self._add(req.name, Platform(plat.os)) -# elif match_os: -# self._add(req.name, Platform(plat.os)) -# elif match_version and self._default_minor_version: -# self._add(req.name, Platform(minor_version=plat.minor_version)) -# if plat.minor_version == self._default_minor_version: -# self._add(req.name, Platform()) -# elif match_version: -# self._add(req.name, None) - -# # Merge to common if possible after processing all platforms -# self._maybe_add_common_dep(req.name) - -# self.name: str = Deps._normalize(name) -# self._platforms: Set[Platform] = platforms or set() -# self._target_versions = {p.minor_version for p in platforms or {}} - -# self._default_minor_version = None -# if platforms and len(self._target_versions) > 2: -# # TODO @aignas 2024-06-23: enable this to be set via a CLI arg -# # for being more explicit. -# self._default_minor_version = host_interpreter_minor_version() - -# if None in self._target_versions and len(self._target_versions) > 2: -# raise ValueError( -# f"all python versions need to be specified explicitly, got: {platforms}" -# ) - -# # Sort so that the dictionary order in the FrozenDeps is deterministic -# # without the final sort because Python retains insertion order. That way -# # the sorting by platform is limited within the Platform class itself and -# # the unit-tests for the Deps can be simpler. -# reqs = sorted( -# (Requirement(wheel_req) for wheel_req in requires_dist), -# key=lambda x: f"{x.name}:{sorted(x.extras)}", -# ) - -# want_extras = self._resolve_extras(reqs, extras) - -# # Then add all of the requirements in order -# self._deps: Set[str] = set() -# self._select: Dict[Platform, Set[str]] = defaultdict(set) -# for req in reqs: -# self._add_req(req, want_extras) - -# def _add(self, dep: str, platform: Optional[Platform]): -# dep = Deps._normalize(dep) - -# # Self-edges are processed in _resolve_extras -# if dep == self.name: -# return - -# if not platform: -# self._deps.add(dep) - -# # If the dep is in the platform-specific list, remove it from the select. -# pop_keys = [] -# for p, deps in self._select.items(): -# if dep not in deps: -# continue - -# deps.remove(dep) -# if not deps: -# pop_keys.append(p) - -# for p in pop_keys: -# self._select.pop(p) -# return - -# if dep in self._deps: -# # If the dep is already in the main dependency list, no need to add it in the -# # platform-specific dependency list. -# return - -# # Add the platform-specific dep -# self._select[platform].add(dep) - -# # Add the dep to specializations of the given platform if they -# # exist in the select statement. -# for p in platform.all_specializations(): -# if p not in self._select: -# continue - -# self._select[p].add(dep) - -# if len(self._select[platform]) == 1: -# # We are adding a new item to the select and we need to ensure that -# # existing dependencies from less specialized platforms are propagated -# # to the newly added dependency set. -# for p, deps in self._select.items(): -# # Check if the existing platform overlaps with the given platform -# if p == platform or platform not in p.all_specializations(): -# continue - -# self._select[platform].update(self._select[p]) - -# def _resolve_extras( -# self, reqs: List[Requirement], extras: Optional[Set[str]] -# ) -> Set[str]: -# """Resolve extras which are due to depending on self[some_other_extra]. - -# Some packages may have cyclic dependencies resulting from extras being used, one example is -# `etils`, where we have one set of extras as aliases for other extras -# and we have an extra called 'all' that includes all other extras. - -# Example: github.com/google/etils/blob/a0b71032095db14acf6b33516bca6d885fe09e35/pyproject.toml#L32. - -# When the `requirements.txt` is generated by `pip-tools`, then it is likely that -# this step is not needed, but for other `requirements.txt` files this may be useful. - -# NOTE @aignas 2023-12-08: the extra resolution is not platform dependent, -# but in order for it to become platform dependent we would have to have -# separate targets for each extra in extras. -# """ - -# # Resolve any extra extras due to self-edges, empty string means no -# # extras The empty string in the set is just a way to make the handling -# # of no extras and a single extra easier and having a set of {"", "foo"} -# # is equivalent to having {"foo"}. -# extras = extras or {""} - -# self_reqs = [] -# for req in reqs: -# if Deps._normalize(req.name) != self.name: -# continue - -# if req.marker is None: -# # I am pretty sure we cannot reach this code as it does not -# # make sense to specify packages in this way, but since it is -# # easy to handle, lets do it. -# # -# # TODO @aignas 2023-12-08: add a test -# extras = extras | req.extras -# else: -# # process these in a separate loop -# self_reqs.append(req) - -# # A double loop is not strictly optimal, but always correct without recursion -# for req in self_reqs: -# if any(req.marker.evaluate({"extra": extra}) for extra in extras): -# extras = extras | req.extras -# else: -# continue - -# # Iterate through all packages to ensure that we include all of the extras from previously -# # visited packages. -# for req_ in self_reqs: -# if any(req_.marker.evaluate({"extra": extra}) for extra in extras): -# extras = extras | req_.extras - -# return extras - -# def _add_req(self, req: Requirement, extras: Set[str]) -> None: -# if req.marker is None: -# self._add(req.name, None) -# return - -# marker_str = str(req.marker) - -# if not self._platforms: -# if any(req.marker.evaluate({"extra": extra}) for extra in extras): -# self._add(req.name, None) -# return - -# # NOTE @aignas 2023-12-08: in order to have reasonable select statements -# # we do have to have some parsing of the markers, so it begs the question -# # if packaging should be reimplemented in Starlark to have the best solution -# # for now we will implement it in Python and see what the best parsing result -# # can be before making this decision. -# match_os = any( -# tag in marker_str -# for tag in [ -# "os_name", -# "sys_platform", -# "platform_system", -# ] -# ) -# match_arch = "platform_machine" in marker_str -# match_version = "version" in marker_str - -# if not (match_os or match_arch or match_version): -# if any(req.marker.evaluate({"extra": extra}) for extra in extras): -# self._add(req.name, None) -# return - -# for plat in self._platforms: -# if not any( -# req.marker.evaluate(plat.env_markers(extra)) for extra in extras -# ): -# continue - -# if match_arch and self._default_minor_version: -# self._add(req.name, plat) -# if plat.minor_version == self._default_minor_version: -# self._add(req.name, Platform(plat.os, plat.arch)) -# elif match_arch: -# self._add(req.name, Platform(plat.os, plat.arch)) -# elif match_os and self._default_minor_version: -# self._add(req.name, Platform(plat.os, minor_version=plat.minor_version)) -# if plat.minor_version == self._default_minor_version: -# self._add(req.name, Platform(plat.os)) -# elif match_os: -# self._add(req.name, Platform(plat.os)) -# elif match_version and self._default_minor_version: -# self._add(req.name, Platform(minor_version=plat.minor_version)) -# if plat.minor_version == self._default_minor_version: -# self._add(req.name, Platform()) -# elif match_version: -# self._add(req.name, None) - -# # Merge to common if possible after processing all platforms -# self._maybe_add_common_dep(req.name) - -# def build(self) -> FrozenDeps: -# return FrozenDeps( -# deps=sorted(self._deps), -# deps_select={str(p): sorted(deps) for p, deps in self._select.items()}, -# ) diff --git a/python/private/pypi/pep508_req.bzl b/python/private/pypi/pep508_req.bzl new file mode 100644 index 0000000000..fbb54adee1 --- /dev/null +++ b/python/private/pypi/pep508_req.bzl @@ -0,0 +1,38 @@ +# Copyright 2025 The Bazel Authors. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""This module is for parsing PEP508 requires-dist and requirements lines. +""" + +load("//python/private:normalize_name.bzl", "normalize_name") + +def requirement(spec): + """Parse a PEP508 requirement line + + Args: + spec: {type}`str` requirement line that will be parsed. + + Returns: + A struct with the information. + """ + requires, _, marker = spec.partition(";") + requires, _, extras_unparsed = requires.partition("[") + requires, _, _ = requires.partition("(") + requires, _, _ = requires.partition(" ") + extras = extras_unparsed.strip("]").split(",") + return struct( + name = normalize_name(requires.strip(" ")), + marker = marker.strip(" "), + extras = extras, + ) diff --git a/tests/pypi/pep508/deps_tests.bzl b/tests/pypi/pep508/deps_tests.bzl index 8f144cf0a3..d8616c7b34 100644 --- a/tests/pypi/pep508/deps_tests.bzl +++ b/tests/pypi/pep508/deps_tests.bzl @@ -22,7 +22,6 @@ def test_simple_deps(env): got = deps( "foo", requires_dist = ["bar-Bar"], - platforms = ["cp38_linux_x86_64"], ) env.expect.that_collection(got.deps).contains_exactly(["bar_bar"]) env.expect.that_dict(got.deps_select).contains_exactly({}) @@ -162,7 +161,6 @@ def test_self_is_ignored(env): "ssl_lib; extra == 'ssl'", ], extras = ["ssl"], - platforms = ["cp38_linux_x86_64"], ) env.expect.that_collection(got.deps).contains_exactly(["bar", "req_dep", "ssl_lib"]) @@ -181,7 +179,6 @@ def test_self_dependencies_can_come_in_any_order(env): "zdep; extra == 'all'", ], extras = ["all"], - platforms = ["cp38_linux_x86_64"], ) env.expect.that_collection(got.deps).contains_exactly(["bar", "baz", "zdep"]) From 58c75329e4f6a7628c3ebeacdfe8aacb90e32674 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Feb 2025 15:37:36 +0900 Subject: [PATCH 23/65] sorting --- python/private/pypi/pep508_env.bzl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 8e7854d493..91dad2a67f 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -103,7 +103,7 @@ def deps(name, *, requires_dist, platforms = [], extras = [], host_python_versio """ reqs = sorted( [_req(r) for r in requires_dist], - key = lambda x: x.name, + key = lambda x: "{}:{}".format(x.name, sorted(x.extras)), ) deps = {} deps_select = {} From ef1caccedae2791952dbc45e990e6f218ff7ba05 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Feb 2025 15:40:12 +0900 Subject: [PATCH 24/65] wip --- python/private/pypi/pep508_env.bzl | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 91dad2a67f..83c24dd8c3 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -187,6 +187,11 @@ def _platform_str(self): ) def _platform_specializations(self): + """Return the platform itself and all its unambiguous specializations. + + For more info about specializations see + https://bazel.build/docs/configurable-attributes + """ specializations = [] specializations.append(self) if self.arch == None: From 67f12e81b5fd4fea3a16a483117f07a88e20527c Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Mon, 24 Feb 2025 00:16:10 +0900 Subject: [PATCH 25/65] reorder and cleanr --- python/private/pypi/pep508_env.bzl | 200 +++++++++++++++-------------- 1 file changed, 107 insertions(+), 93 deletions(-) diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 83c24dd8c3..542771dfa9 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -103,7 +103,7 @@ def deps(name, *, requires_dist, platforms = [], extras = [], host_python_versio """ reqs = sorted( [_req(r) for r in requires_dist], - key = lambda x: "{}:{}".format(x.name, sorted(x.extras)), + key = lambda x: "{}:{}:".format(x.name, sorted(x.extras), x.marker), ) deps = {} deps_select = {} @@ -122,7 +122,9 @@ def deps(name, *, requires_dist, platforms = [], extras = [], host_python_versio abis = sorted({p.abi: True for p in platforms if p.abi}) if host_python_version and len(abis) > 1: - default_abi = "cp3" + host_python_version[2:].partition(".")[0] + _, _, minor_version = host_python_version.partition(".") + minor_version, _, _ = minor_version.partition(".") + default_abi = "cp3" + minor_version elif len(abis) > 1: fail( "all python versions need to be specified explicitly, got: {}".format(platforms), @@ -212,73 +214,10 @@ def _platform_specializations(self): ]) return specializations -def _add_req(deps, deps_select, req, *, extras, platforms, default_abi = None): - if not req.marker: - _add(deps, deps_select, req.name, None) - return - - # NOTE @aignas 2023-12-08: in order to have reasonable select statements - # we do have to have some parsing of the markers, so it begs the question - # if packaging should be reimplemented in Starlark to have the best solution - # for now we will implement it in Python and see what the best parsing result - # can be before making this decision. - match_os = len([ - tag - for tag in [ - "os_name", - "sys_platform", - "platform_system", - ] - if tag in req.marker - ]) > 0 - match_arch = "platform_machine" in req.marker - match_version = "version" in req.marker - - if not (match_os or match_arch or match_version): - if [ - True - for extra in extras - for p in platforms - if evaluate( - req.marker, - env = env( - target_platform = p, - extra = extra, - ), - ) - ]: - _add(deps, deps_select, req.name, None) - return - - for plat in platforms: - if not evaluate(req.marker, env = env(plat)): - continue - - if match_arch and default_abi: - _add(deps, deps_select, req.name, plat) - if plat.abi == default_abi: - _add(deps, deps_select, req.name, _platform(os = plat.os, arch = plat.arch)) - elif match_arch: - _add(deps, deps_select, req.name, _platform(os = plat.os, arch = plat.arch)) - elif match_os and default_abi: - _add(deps, deps_select, req.name, _platform(os = plat.os, abi = plat.abi)) - if plat.abi == default_abi: - _add(deps, deps_select, req.name, _platform(os = plat.os)) - elif match_os: - _add(deps, deps_select, req.name, _platform(os = plat.os)) - elif match_version and default_abi: - _add(deps, deps_select, req.name, _platform(abi = plat.abi)) - if plat.abi == default_abi: - _add(deps, deps_select, req.name, _platform()) - elif match_version: - _add(deps, deps_select, req.name, None) - else: - fail("BUG: {} support is not implemented".format(req.marker)) - - _maybe_add_common_dep(deps, deps_select, platforms, req.name) - def _add(deps, deps_select, dep, platform): - if not platform: + dep = normalize_name(dep) + + if platform == None: deps[dep] = True # If the dep is in the platform-specific list, remove it from the select. @@ -300,8 +239,8 @@ def _add(deps, deps_select, dep, platform): # platform-specific dependency list. return - # Add the platform-specific dep - deps_select.setdefault(platform, {})[dep] = True + # Add the platform-specific branch + deps_select.setdefault(platform, {}) # Add the dep to specializations of the given platform if they # exist in the select statement. @@ -315,12 +254,39 @@ def _add(deps, deps_select, dep, platform): # We are adding a new item to the select and we need to ensure that # existing dependencies from less specialized platforms are propagated # to the newly added dependency set. - for p, deps in deps_select.items(): + for p, _deps in deps_select.items(): # Check if the existing platform overlaps with the given platform if p == platform or platform not in _platform_specializations(p): continue - deps_select[platform].update(deps) + deps_select[platform].update(_deps) + +def _maybe_add_common_dep(deps, deps_select, platforms, dep): + abis = sorted({p.abi: True for p in platforms if p.abi}) + if len(abis) < 2: + return + + platforms = [_platform()] + [ + _platform(abi = abi) + for abi in abis + ] + + # If the dep is targeting all target python versions, lets add it to + # the common dependency list to simplify the select statements. + for p in platforms: + if p not in deps_select: + return + + if dep not in deps_select[p]: + return + + # All of the python version-specific branches have the dep, so lets add + # it to the common deps. + deps[dep] = True + for p in platforms: + deps_select[p].pop(dep) + if not deps_select[p]: + deps_select.pop(p) def _resolve_extras(self_name, reqs, extras): """Resolve extras which are due to depending on self[some_other_extra]. @@ -377,29 +343,77 @@ def _resolve_extras(self_name, reqs, extras): # Poor mans set return sorted({x: None for x in extras}) -def _maybe_add_common_dep(deps, deps_select, platforms, dep): - abis = sorted({p.abi: True for p in platforms if p.abi}) - if len(abis) < 2: +def _add_req(deps, deps_select, req, *, extras, platforms, default_abi = None): + if not req.marker: + _add(deps, deps_select, req.name, None) return - platforms = [_platform()] + [ - _platform(abi = abi) - for abi in abis - ] + # NOTE @aignas 2023-12-08: in order to have reasonable select statements + # we do have to have some parsing of the markers, so it begs the question + # if packaging should be reimplemented in Starlark to have the best solution + # for now we will implement it in Python and see what the best parsing result + # can be before making this decision. + match_os = len([ + tag + for tag in [ + "os_name", + "sys_platform", + "platform_system", + ] + if tag in req.marker + ]) > 0 + match_arch = "platform_machine" in req.marker + match_version = "version" in req.marker - # If the dep is targeting all target python versions, lets add it to - # the common dependency list to simplify the select statements. - for p in platforms: - if p not in deps_select: - return + if not (match_os or match_arch or match_version): + if [ + True + for extra in extras + for p in platforms + if evaluate( + req.marker, + env = env( + target_platform = p, + extra = extra, + ), + ) + ]: + _add(deps, deps_select, req.name, None) + return - if dep not in deps_select[p]: - return + for plat in platforms: + if not [ + True + for extra in extras + if evaluate( + req.marker, + env = env( + target_platform = plat, + extra = extra, + ), + ) + ]: + continue - # All of the python version-specific branches have the dep, so lets add - # it to the common deps. - deps[dep] = True - for p in platforms: - deps_select[p].pop(dep) - if not deps_select[p]: - deps_select.pop(p) + if match_arch and default_abi: + _add(deps, deps_select, req.name, plat) + if plat.abi == default_abi: + _add(deps, deps_select, req.name, _platform(os = plat.os, arch = plat.arch)) + elif match_arch: + _add(deps, deps_select, req.name, _platform(os = plat.os, arch = plat.arch)) + elif match_os and default_abi: + _add(deps, deps_select, req.name, _platform(os = plat.os, abi = plat.abi)) + if plat.abi == default_abi: + _add(deps, deps_select, req.name, _platform(os = plat.os)) + elif match_os: + _add(deps, deps_select, req.name, _platform(os = plat.os)) + elif match_version and default_abi: + _add(deps, deps_select, req.name, _platform(abi = plat.abi)) + if plat.abi == default_abi: + _add(deps, deps_select, req.name, _platform()) + elif match_version: + _add(deps, deps_select, req.name, None) + else: + fail("BUG: {} support is not implemented".format(req.marker)) + + _maybe_add_common_dep(deps, deps_select, platforms, req.name) From 72fdac676cc9dfd1952df2ecabe7fbbbaeb4ca4b Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Mon, 24 Feb 2025 00:26:49 +0900 Subject: [PATCH 26/65] wip --- tests/pypi/pep508/deps_tests.bzl | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/tests/pypi/pep508/deps_tests.bzl b/tests/pypi/pep508/deps_tests.bzl index d8616c7b34..092184c3cb 100644 --- a/tests/pypi/pep508/deps_tests.bzl +++ b/tests/pypi/pep508/deps_tests.bzl @@ -366,8 +366,15 @@ def _test_deps_are_not_duplicated_when_encountering_platform_dep_first(env): host_python_version = host_python_version, ) - env.expect.that_collection(got.deps).contains_exactly(["bar"]) - env.expect.that_dict(got.deps_select).contains_exactly({}) + # TODO @aignas 2025-02-24: this test case in the python version is passing but + # I am not sure why. The starlark version behaviour looks more correct. + env.expect.that_collection(got.deps).contains_exactly([]) + env.expect.that_dict(got.deps_select).contains_exactly({ + "@//python/config_settings:is_python_3.10": ["bar"], + "cp310_linux_aarch64": ["bar"], + "cp37_linux_aarch64": ["bar"], + "linux_aarch64": ["bar"], + }) _tests.append(_test_deps_are_not_duplicated_when_encountering_platform_dep_first) From 18fe4cc1d8c391a834aed1c0394865b87814a020 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Mon, 24 Feb 2025 00:43:08 +0900 Subject: [PATCH 27/65] use starlark to eval markers --- python/private/pypi/evaluate_markers.bzl | 57 +++++----------------- python/private/pypi/extension.bzl | 18 +------ python/private/pypi/parse_requirements.bzl | 12 ++--- python/private/pypi/pep508_env.bzl | 15 ++++-- python/private/pypi/pep508_evaluate.bzl | 2 +- python/private/pypi/pep508_req.bzl | 4 +- python/private/pypi/pip_repository.bzl | 15 +----- 7 files changed, 39 insertions(+), 84 deletions(-) diff --git a/python/private/pypi/evaluate_markers.bzl b/python/private/pypi/evaluate_markers.bzl index ec5f576945..c2709dbf79 100644 --- a/python/private/pypi/evaluate_markers.bzl +++ b/python/private/pypi/evaluate_markers.bzl @@ -15,7 +15,9 @@ """A simple function that evaluates markers using a python interpreter.""" load(":deps.bzl", "record_files") -load(":pypi_repo_utils.bzl", "pypi_repo_utils") +load(":pep508_env.bzl", "env", _platform_from_str = "platform_from_str") +load(":pep508_evaluate.bzl", "evaluate") +load(":pep508_req.bzl", _req = "requirement") # Used as a default value in a rule to ensure we fetch the dependencies. SRCS = [ @@ -26,53 +28,20 @@ SRCS = [ Label("//python/private/pypi/whl_installer:platform.py"), ] -def evaluate_markers(mrctx, *, requirements, python_interpreter, python_interpreter_target, srcs, logger = None): +def evaluate_markers(requirements): """Return the list of supported platforms per requirements line. Args: - mrctx: repository_ctx or module_ctx. - requirements: list[str] of the requirement file lines to evaluate. - python_interpreter: str, path to the python_interpreter to use to - evaluate the env markers in the given requirements files. It will - be only called if the requirements files have env markers. This - should be something that is in your PATH or an absolute path. - python_interpreter_target: Label, same as python_interpreter, but in a - label format. - srcs: list[Label], the value of SRCS passed from the `rctx` or `mctx` to this function. - logger: repo_utils.logger or None, a simple struct to log diagnostic - messages. Defaults to None. + requirements: dict[str, list[str]] of the requirement file lines to evaluate. Returns: dict of string lists with target platforms """ - if not requirements: - return {} - - in_file = mrctx.path("requirements_with_markers.in.json") - out_file = mrctx.path("requirements_with_markers.out.json") - mrctx.file(in_file, json.encode(requirements)) - - pypi_repo_utils.execute_checked( - mrctx, - op = "ResolveRequirementEnvMarkers({})".format(in_file), - arguments = [ - pypi_repo_utils.resolve_python_interpreter( - mrctx, - python_interpreter = python_interpreter, - python_interpreter_target = python_interpreter_target, - ), - "-m", - "python.private.pypi.requirements_parser.resolve_target_platforms", - in_file, - out_file, - ], - srcs = srcs, - environment = { - "PYTHONPATH": [ - Label("@pypi__packaging//:BUILD.bazel"), - Label("//:BUILD.bazel"), - ], - }, - logger = logger, - ) - return json.decode(mrctx.read(out_file)) + ret = {} + for req_string, platforms in requirements.items(): + req = _req(req_string) + for platform in platforms: + if evaluate(req.marker, env = env(_platform_from_str(platform, None))): + ret.setdefault(req_string, []).append(platform) + + return ret diff --git a/python/private/pypi/extension.bzl b/python/private/pypi/extension.bzl index 405c22f60e..92d1d50937 100644 --- a/python/private/pypi/extension.bzl +++ b/python/private/pypi/extension.bzl @@ -22,7 +22,7 @@ load("//python/private:repo_utils.bzl", "repo_utils") load("//python/private:semver.bzl", "semver") load("//python/private:version_label.bzl", "version_label") load(":attrs.bzl", "use_isolated") -load(":evaluate_markers.bzl", "evaluate_markers", EVALUATE_MARKERS_SRCS = "SRCS") +load(":evaluate_markers.bzl", "evaluate_markers") load(":hub_repository.bzl", "hub_repository", "whl_config_settings_to_json") load(":parse_requirements.bzl", "parse_requirements") load(":parse_whl_name.bzl", "parse_whl_name") @@ -180,14 +180,7 @@ def _create_whl_repos( # instances to perform this manipulation. This function should be executed # only once by the underlying code to minimize the overhead needed to # spin up a Python interpreter. - evaluate_markers = lambda module_ctx, requirements: evaluate_markers( - module_ctx, - requirements = requirements, - python_interpreter = pip_attr.python_interpreter, - python_interpreter_target = python_interpreter_target, - srcs = pip_attr._evaluate_markers_srcs, - logger = logger, - ), + evaluate_markers = lambda r: evaluate_markers(r), logger = logger, ) @@ -759,13 +752,6 @@ a corresponding `python.toolchain()` configured. doc = """\ A dict of labels to wheel names that is typically generated by the whl_modifications. The labels are JSON config files describing the modifications. -""", - ), - "_evaluate_markers_srcs": attr.label_list( - default = EVALUATE_MARKERS_SRCS, - doc = """\ -The list of labels to use as SRCS for the marker evaluation code. This ensures that the -code will be re-evaluated when any of files in the default changes. """, ), }, **ATTRS) diff --git a/python/private/pypi/parse_requirements.bzl b/python/private/pypi/parse_requirements.bzl index 2bca8d8621..f36a97eb26 100644 --- a/python/private/pypi/parse_requirements.bzl +++ b/python/private/pypi/parse_requirements.bzl @@ -67,10 +67,10 @@ def parse_requirements( of the distribution URLs from a PyPI index. Accepts ctx and distribution names to query. evaluate_markers: A function to use to evaluate the requirements. - Accepts the ctx and a dict where keys are requirement lines to - evaluate against the platforms stored as values in the input dict. - Returns the same dict, but with values being platforms that are - compatible with the requirements line. + Accepts a dict where keys are requirement lines to evaluate against + the platforms stored as values in the input dict. Returns the same + dict, but with values being platforms that are compatible with the + requirements line. logger: repo_utils.logger or None, a simple struct to log diagnostic messages. Returns: @@ -93,7 +93,7 @@ def parse_requirements( The second element is extra_pip_args should be passed to `whl_library`. """ - evaluate_markers = evaluate_markers or (lambda *_: {}) + evaluate_markers = evaluate_markers or (lambda _: {}) options = {} requirements = {} for file, plats in requirements_by_platform.items(): @@ -168,7 +168,7 @@ def parse_requirements( # to do, we could use Python to parse the requirement lines and infer the # URL of the files to download things from. This should be important for # VCS package references. - env_marker_target_platforms = evaluate_markers(ctx, reqs_with_env_markers) + env_marker_target_platforms = evaluate_markers(reqs_with_env_markers) if logger: logger.debug(lambda: "Evaluated env markers from:\n{}\n\nTo:\n{}".format( reqs_with_env_markers, diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 542771dfa9..2629051af1 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -114,10 +114,10 @@ def deps(name, *, requires_dist, platforms = [], extras = [], host_python_versio reqs = [r for r in reqs if r.name != name] platforms = [ - _platform_from_str(p, python_version = host_python_version) + platform_from_str(p, python_version = host_python_version) for p in platforms ] or [ - _platform_from_str("", python_version = host_python_version), + platform_from_str("", python_version = host_python_version), ] abis = sorted({p.abi: True for p in platforms if p.abi}) @@ -157,7 +157,16 @@ def _platform(*, abi = None, os = None, arch = None): arch = arch, ) -def _platform_from_str(p, python_version): +def platform_from_str(p, python_version): + """Return a platform from a string. + + Args: + p: {type}`str` the actual string. + python_version: {type}`str` the python version to add to platform if needed. + + Returns: + A struct that is returned by the `_platform` function. + """ if p.startswith("cp"): abi, _, p = p.partition("_") elif python_version: diff --git a/python/private/pypi/pep508_evaluate.bzl b/python/private/pypi/pep508_evaluate.bzl index 6703b3fcd0..a5082df95e 100644 --- a/python/private/pypi/pep508_evaluate.bzl +++ b/python/private/pypi/pep508_evaluate.bzl @@ -114,7 +114,7 @@ def tokenize(marker): elif char in _WSP: state = _STATE.NONE else: - fail("BUG: Cannot parse '{}' in {}".format(char, state)) + fail("BUG: Cannot parse '{}' in {} ({})".format(char, state, marker)) else: token += char diff --git a/python/private/pypi/pep508_req.bzl b/python/private/pypi/pep508_req.bzl index fbb54adee1..43159b3ed8 100644 --- a/python/private/pypi/pep508_req.bzl +++ b/python/private/pypi/pep508_req.bzl @@ -26,11 +26,13 @@ def requirement(spec): Returns: A struct with the information. """ - requires, _, marker = spec.partition(";") + requires, _, maybe_hashes = spec.partition(";") + marker, _, _ = maybe_hashes.partition("--hash") requires, _, extras_unparsed = requires.partition("[") requires, _, _ = requires.partition("(") requires, _, _ = requires.partition(" ") extras = extras_unparsed.strip("]").split(",") + return struct( name = normalize_name(requires.strip(" ")), marker = marker.strip(" "), diff --git a/python/private/pypi/pip_repository.bzl b/python/private/pypi/pip_repository.bzl index 029566eea3..7f0ea9827a 100644 --- a/python/private/pypi/pip_repository.bzl +++ b/python/private/pypi/pip_repository.bzl @@ -18,7 +18,7 @@ load("@bazel_skylib//lib:sets.bzl", "sets") load("//python/private:normalize_name.bzl", "normalize_name") load("//python/private:repo_utils.bzl", "REPO_DEBUG_ENV_VAR") load("//python/private:text_util.bzl", "render") -load(":evaluate_markers.bzl", "evaluate_markers", EVALUATE_MARKERS_SRCS = "SRCS") +load(":evaluate_markers.bzl", "evaluate_markers") load(":parse_requirements.bzl", "host_platform", "parse_requirements", "select_requirement") load(":pip_repository_attrs.bzl", "ATTRS") load(":render_pkg_aliases.bzl", "render_pkg_aliases") @@ -82,12 +82,8 @@ def _pip_repository_impl(rctx): extra_pip_args = rctx.attr.extra_pip_args, ), extra_pip_args = rctx.attr.extra_pip_args, - evaluate_markers = lambda rctx, requirements: evaluate_markers( - rctx, + evaluate_markers = lambda requirements: evaluate_markers( requirements = requirements, - python_interpreter = rctx.attr.python_interpreter, - python_interpreter_target = rctx.attr.python_interpreter_target, - srcs = rctx.attr._evaluate_markers_srcs, ), ) selected_requirements = {} @@ -234,13 +230,6 @@ file](https://github.com/bazelbuild/rules_python/blob/main/examples/pip_reposito _template = attr.label( default = ":requirements.bzl.tmpl.workspace", ), - _evaluate_markers_srcs = attr.label_list( - default = EVALUATE_MARKERS_SRCS, - doc = """\ -The list of labels to use as SRCS for the marker evaluation code. This ensures that the -code will be re-evaluated when any of files in the default changes. -""", - ), **ATTRS ), doc = """Accepts a locked/compiled requirements file and installs the dependencies listed within. From 58755bdcdaf342fbf4552cfd003817f627a5d980 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Mon, 24 Feb 2025 00:44:34 +0900 Subject: [PATCH 28/65] cleanup dead code --- python/private/pypi/evaluate_markers.bzl | 10 --- .../pypi/requirements_parser/BUILD.bazel | 0 .../resolve_target_platforms.py | 63 ------------------- 3 files changed, 73 deletions(-) delete mode 100644 python/private/pypi/requirements_parser/BUILD.bazel delete mode 100755 python/private/pypi/requirements_parser/resolve_target_platforms.py diff --git a/python/private/pypi/evaluate_markers.bzl b/python/private/pypi/evaluate_markers.bzl index c2709dbf79..1d4c30753f 100644 --- a/python/private/pypi/evaluate_markers.bzl +++ b/python/private/pypi/evaluate_markers.bzl @@ -14,20 +14,10 @@ """A simple function that evaluates markers using a python interpreter.""" -load(":deps.bzl", "record_files") load(":pep508_env.bzl", "env", _platform_from_str = "platform_from_str") load(":pep508_evaluate.bzl", "evaluate") load(":pep508_req.bzl", _req = "requirement") -# Used as a default value in a rule to ensure we fetch the dependencies. -SRCS = [ - # When the version, or any of the files in `packaging` package changes, - # this file will change as well. - record_files["pypi__packaging"], - Label("//python/private/pypi/requirements_parser:resolve_target_platforms.py"), - Label("//python/private/pypi/whl_installer:platform.py"), -] - def evaluate_markers(requirements): """Return the list of supported platforms per requirements line. diff --git a/python/private/pypi/requirements_parser/BUILD.bazel b/python/private/pypi/requirements_parser/BUILD.bazel deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/python/private/pypi/requirements_parser/resolve_target_platforms.py b/python/private/pypi/requirements_parser/resolve_target_platforms.py deleted file mode 100755 index c899a943cc..0000000000 --- a/python/private/pypi/requirements_parser/resolve_target_platforms.py +++ /dev/null @@ -1,63 +0,0 @@ -"""A CLI to evaluate env markers for requirements files. - -A simple script to evaluate the `requirements.txt` files. Currently it is only -handling environment markers in the requirements files, but in the future it -may handle more things. We require a `python` interpreter that can run on the -host platform and then we depend on the [packaging] PyPI wheel. - -In order to be able to resolve requirements files for any platform, we are -re-using the same code that is used in the `whl_library` installer. See -[here](../whl_installer/wheel.py). - -Requirements for the code are: -- Depends only on `packaging` and core Python. -- Produces the same result irrespective of the Python interpreter platform or version. - -[packaging]: https://packaging.pypa.io/en/stable/ -""" - -import argparse -import json -import pathlib - -from packaging.requirements import Requirement - -from python.private.pypi.whl_installer.platform import Platform - -INPUT_HELP = """\ -Input path to read the requirements as a json file, the keys in the dictionary -are the requirements lines and the values are strings of target platforms. -""" -OUTPUT_HELP = """\ -Output to write the requirements as a json filepath, the keys in the dictionary -are the requirements lines and the values are strings of target platforms, which -got changed based on the evaluated markers. -""" - - -def main(): - parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument("input_path", type=pathlib.Path, help=INPUT_HELP.strip()) - parser.add_argument("output_path", type=pathlib.Path, help=OUTPUT_HELP.strip()) - args = parser.parse_args() - - with args.input_path.open() as f: - reqs = json.load(f) - - response = {} - for requirement_line, target_platforms in reqs.items(): - entry, prefix, hashes = requirement_line.partition("--hash") - hashes = prefix + hashes - - req = Requirement(entry) - for p in target_platforms: - (platform,) = Platform.from_string(p) - if not req.marker or req.marker.evaluate(platform.env_markers("")): - response.setdefault(requirement_line, []).append(p) - - with args.output_path.open("w") as f: - json.dump(response, f) - - -if __name__ == "__main__": - main() From b4fe6709d41edda0221221323078db5f8c151140 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Mon, 24 Feb 2025 00:47:00 +0900 Subject: [PATCH 29/65] add bzl libs --- python/private/pypi/BUILD.bazel | 31 ++++++++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/python/private/pypi/BUILD.bazel b/python/private/pypi/BUILD.bazel index 6f80272af6..97fb00da7a 100644 --- a/python/private/pypi/BUILD.bazel +++ b/python/private/pypi/BUILD.bazel @@ -75,7 +75,9 @@ bzl_library( name = "evaluate_markers_bzl", srcs = ["evaluate_markers.bzl"], deps = [ - ":pypi_repo_utils_bzl", + ":pep508_env_bzl", + ":pep508_evaluate_bzl", + ":pep508_req_bzl", ], ) @@ -208,6 +210,33 @@ bzl_library( ], ) +bzl_library( + name = "pep508_evaluate_bzl", + srcs = ["pep508_evaluate.bzl"], + deps = [ + "//python/private:enum_bzl", + "//python/private:semver_bzl", + ], +) + +bzl_library( + name = "pep508_req_bzl", + srcs = ["pep508_req.bzl"], + deps = [ + "//python/private:normalize_name_bzl", + ], +) + +bzl_library( + name = "pep508_env_bzl", + srcs = ["pep508_env.bzl"], + deps = [ + ":pep508_evaluate_bzl", + ":pep508_req_bzl", + "//python/private:normalize_name_bzl", + ], +) + bzl_library( name = "pip_bzl", srcs = ["pip.bzl"], From e0486356e8b8d422baec121e0a561925d4a774db Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Mon, 24 Feb 2025 00:48:23 +0900 Subject: [PATCH 30/65] temp addition of the module lock file --- MODULE.bazel.lock | 6688 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 6688 insertions(+) create mode 100644 MODULE.bazel.lock diff --git a/MODULE.bazel.lock b/MODULE.bazel.lock new file mode 100644 index 0000000000..4b701a6c13 --- /dev/null +++ b/MODULE.bazel.lock @@ -0,0 +1,6688 @@ +{ + "lockFileVersion": 18, + "registryFileHashes": { + "https://bcr.bazel.build/bazel_registry.json": "8a28e4aff06ee60aed2a8c281907fb8bcbf3b753c91fb5a5c57da3215d5b3497", + "https://bcr.bazel.build/modules/abseil-cpp/20210324.2/MODULE.bazel": "7cd0312e064fde87c8d1cd79ba06c876bd23630c83466e9500321be55c96ace2", + "https://bcr.bazel.build/modules/abseil-cpp/20211102.0/MODULE.bazel": "70390338f7a5106231d20620712f7cccb659cd0e9d073d1991c038eb9fc57589", + "https://bcr.bazel.build/modules/abseil-cpp/20230125.1/MODULE.bazel": "89047429cb0207707b2dface14ba7f8df85273d484c2572755be4bab7ce9c3a0", + "https://bcr.bazel.build/modules/abseil-cpp/20230802.0.bcr.1/MODULE.bazel": "1c8cec495288dccd14fdae6e3f95f772c1c91857047a098fad772034264cc8cb", + "https://bcr.bazel.build/modules/abseil-cpp/20230802.0/MODULE.bazel": "d253ae36a8bd9ee3c5955384096ccb6baf16a1b1e93e858370da0a3b94f77c16", + "https://bcr.bazel.build/modules/abseil-cpp/20230802.1/MODULE.bazel": "fa92e2eb41a04df73cdabeec37107316f7e5272650f81d6cc096418fe647b915", + "https://bcr.bazel.build/modules/abseil-cpp/20240116.1/MODULE.bazel": "37bcdb4440fbb61df6a1c296ae01b327f19e9bb521f9b8e26ec854b6f97309ed", + "https://bcr.bazel.build/modules/abseil-cpp/20240116.1/source.json": "9be551b8d4e3ef76875c0d744b5d6a504a27e3ae67bc6b28f46415fd2d2957da", + "https://bcr.bazel.build/modules/bazel_ci_rules/1.0.0/MODULE.bazel": "0f92c944b9c466066ed484cfc899cf43fca765df78caca18984c62479f7925eb", + "https://bcr.bazel.build/modules/bazel_ci_rules/1.0.0/source.json": "3405a2a7f9f827a44934b01470faeac1b56fb1304955c98ee9fcd03ad2ca5dcc", + "https://bcr.bazel.build/modules/bazel_features/1.1.0/MODULE.bazel": "cfd42ff3b815a5f39554d97182657f8c4b9719568eb7fded2b9135f084bf760b", + "https://bcr.bazel.build/modules/bazel_features/1.1.1/MODULE.bazel": "27b8c79ef57efe08efccbd9dd6ef70d61b4798320b8d3c134fd571f78963dbcd", + "https://bcr.bazel.build/modules/bazel_features/1.11.0/MODULE.bazel": "f9382337dd5a474c3b7d334c2f83e50b6eaedc284253334cf823044a26de03e8", + "https://bcr.bazel.build/modules/bazel_features/1.15.0/MODULE.bazel": "d38ff6e517149dc509406aca0db3ad1efdd890a85e049585b7234d04238e2a4d", + "https://bcr.bazel.build/modules/bazel_features/1.17.0/MODULE.bazel": "039de32d21b816b47bd42c778e0454217e9c9caac4a3cf8e15c7231ee3ddee4d", + "https://bcr.bazel.build/modules/bazel_features/1.18.0/MODULE.bazel": "1be0ae2557ab3a72a57aeb31b29be347bcdc5d2b1eb1e70f39e3851a7e97041a", + "https://bcr.bazel.build/modules/bazel_features/1.19.0/MODULE.bazel": "59adcdf28230d220f0067b1f435b8537dd033bfff8db21335ef9217919c7fb58", + "https://bcr.bazel.build/modules/bazel_features/1.21.0/MODULE.bazel": "675642261665d8eea09989aa3b8afb5c37627f1be178382c320d1b46afba5e3b", + "https://bcr.bazel.build/modules/bazel_features/1.21.0/source.json": "3e8379efaaef53ce35b7b8ba419df829315a880cb0a030e5bb45c96d6d5ecb5f", + "https://bcr.bazel.build/modules/bazel_features/1.4.1/MODULE.bazel": "e45b6bb2350aff3e442ae1111c555e27eac1d915e77775f6fdc4b351b758b5d7", + "https://bcr.bazel.build/modules/bazel_features/1.9.1/MODULE.bazel": "8f679097876a9b609ad1f60249c49d68bfab783dd9be012faf9d82547b14815a", + "https://bcr.bazel.build/modules/bazel_skylib/1.0.3/MODULE.bazel": "bcb0fd896384802d1ad283b4e4eb4d718eebd8cb820b0a2c3a347fb971afd9d8", + "https://bcr.bazel.build/modules/bazel_skylib/1.1.1/MODULE.bazel": "1add3e7d93ff2e6998f9e118022c84d163917d912f5afafb3058e3d2f1545b5e", + "https://bcr.bazel.build/modules/bazel_skylib/1.2.0/MODULE.bazel": "44fe84260e454ed94ad326352a698422dbe372b21a1ac9f3eab76eb531223686", + "https://bcr.bazel.build/modules/bazel_skylib/1.2.1/MODULE.bazel": "f35baf9da0efe45fa3da1696ae906eea3d615ad41e2e3def4aeb4e8bc0ef9a7a", + "https://bcr.bazel.build/modules/bazel_skylib/1.3.0/MODULE.bazel": "20228b92868bf5cfc41bda7afc8a8ba2a543201851de39d990ec957b513579c5", + "https://bcr.bazel.build/modules/bazel_skylib/1.4.1/MODULE.bazel": "a0dcb779424be33100dcae821e9e27e4f2901d9dfd5333efe5ac6a8d7ab75e1d", + "https://bcr.bazel.build/modules/bazel_skylib/1.4.2/MODULE.bazel": "3bd40978e7a1fac911d5989e6b09d8f64921865a45822d8b09e815eaa726a651", + "https://bcr.bazel.build/modules/bazel_skylib/1.5.0/MODULE.bazel": "32880f5e2945ce6a03d1fbd588e9198c0a959bb42297b2cfaf1685b7bc32e138", + "https://bcr.bazel.build/modules/bazel_skylib/1.6.1/MODULE.bazel": "8fdee2dbaace6c252131c00e1de4b165dc65af02ea278476187765e1a617b917", + "https://bcr.bazel.build/modules/bazel_skylib/1.7.0/MODULE.bazel": "0db596f4563de7938de764cc8deeabec291f55e8ec15299718b93c4423e9796d", + "https://bcr.bazel.build/modules/bazel_skylib/1.7.1/MODULE.bazel": "3120d80c5861aa616222ec015332e5f8d3171e062e3e804a2a0253e1be26e59b", + "https://bcr.bazel.build/modules/bazel_skylib/1.7.1/source.json": "f121b43eeefc7c29efbd51b83d08631e2347297c95aac9764a701f2a6a2bb953", + "https://bcr.bazel.build/modules/buildifier_prebuilt/6.0.0.1/MODULE.bazel": "5d23708e6a5527ab4f151da7accabc22808cb5fb579c8cc4cd4a292da57a5c97", + "https://bcr.bazel.build/modules/buildifier_prebuilt/6.1.2/MODULE.bazel": "2ef4962c8b0b6d8d21928a89190755619254459bc67f870dc0ccb9ba9952d444", + "https://bcr.bazel.build/modules/buildifier_prebuilt/6.1.2/source.json": "19fb45ed3f0d55cbff94e402c39512940833ae3a68f9cbfd9518a1926b609c7c", + "https://bcr.bazel.build/modules/buildozer/7.1.2/MODULE.bazel": "2e8dd40ede9c454042645fd8d8d0cd1527966aa5c919de86661e62953cd73d84", + "https://bcr.bazel.build/modules/buildozer/7.1.2/source.json": "c9028a501d2db85793a6996205c8de120944f50a0d570438fcae0457a5f9d1f8", + "https://bcr.bazel.build/modules/cgrindel_bazel_starlib/0.18.0/MODULE.bazel": "1d548f0c383ec8fce15c14b42b7f5f4fc29e910fb747d54b40d8c949a5dea09c", + "https://bcr.bazel.build/modules/cgrindel_bazel_starlib/0.18.0/source.json": "bb5421fffcf03965cb192a7dfa857c4cfc2d5ed7788d8b97da30f6b9d5706c9e", + "https://bcr.bazel.build/modules/gazelle/0.32.0/MODULE.bazel": "b499f58a5d0d3537f3cf5b76d8ada18242f64ec474d8391247438bf04f58c7b8", + "https://bcr.bazel.build/modules/gazelle/0.33.0/MODULE.bazel": "a13a0f279b462b784fb8dd52a4074526c4a2afe70e114c7d09066097a46b3350", + "https://bcr.bazel.build/modules/gazelle/0.34.0/MODULE.bazel": "abdd8ce4d70978933209db92e436deb3a8b737859e9354fb5fd11fb5c2004c8a", + "https://bcr.bazel.build/modules/gazelle/0.36.0/MODULE.bazel": "e375d5d6e9a6ca59b0cb38b0540bc9a05b6aa926d322f2de268ad267a2ee74c0", + "https://bcr.bazel.build/modules/gazelle/0.40.0/MODULE.bazel": "42ba5378ebe845fca43989a53186ab436d956db498acde790685fe0e8f9c6146", + "https://bcr.bazel.build/modules/gazelle/0.40.0/source.json": "1e5ef6e4d8b9b6836d93273c781e78ff829ea2e077afef7a57298040fa4f010a", + "https://bcr.bazel.build/modules/google_benchmark/1.8.2/MODULE.bazel": "a70cf1bba851000ba93b58ae2f6d76490a9feb74192e57ab8e8ff13c34ec50cb", + "https://bcr.bazel.build/modules/googletest/1.11.0/MODULE.bazel": "3a83f095183f66345ca86aa13c58b59f9f94a2f81999c093d4eeaa2d262d12f4", + "https://bcr.bazel.build/modules/googletest/1.14.0.bcr.1/MODULE.bazel": "22c31a561553727960057361aa33bf20fb2e98584bc4fec007906e27053f80c6", + "https://bcr.bazel.build/modules/googletest/1.14.0.bcr.1/source.json": "41e9e129f80d8c8bf103a7acc337b76e54fad1214ac0a7084bf24f4cd924b8b4", + "https://bcr.bazel.build/modules/googletest/1.14.0/MODULE.bazel": "cfbcbf3e6eac06ef9d85900f64424708cc08687d1b527f0ef65aa7517af8118f", + "https://bcr.bazel.build/modules/jsoncpp/1.9.5/MODULE.bazel": "31271aedc59e815656f5736f282bb7509a97c7ecb43e927ac1a37966e0578075", + "https://bcr.bazel.build/modules/jsoncpp/1.9.5/source.json": "4108ee5085dd2885a341c7fab149429db457b3169b86eb081fa245eadf69169d", + "https://bcr.bazel.build/modules/libpfm/4.11.0/MODULE.bazel": "45061ff025b301940f1e30d2c16bea596c25b176c8b6b3087e92615adbd52902", + "https://bcr.bazel.build/modules/platforms/0.0.10/MODULE.bazel": "8cb8efaf200bdeb2150d93e162c40f388529a25852b332cec879373771e48ed5", + "https://bcr.bazel.build/modules/platforms/0.0.10/source.json": "f22828ff4cf021a6b577f1bf6341cb9dcd7965092a439f64fc1bb3b7a5ae4bd5", + "https://bcr.bazel.build/modules/platforms/0.0.4/MODULE.bazel": "9b328e31ee156f53f3c416a64f8491f7eb731742655a47c9eec4703a71644aee", + "https://bcr.bazel.build/modules/platforms/0.0.5/MODULE.bazel": "5733b54ea419d5eaf7997054bb55f6a1d0b5ff8aedf0176fef9eea44f3acda37", + "https://bcr.bazel.build/modules/platforms/0.0.6/MODULE.bazel": "ad6eeef431dc52aefd2d77ed20a4b353f8ebf0f4ecdd26a807d2da5aa8cd0615", + "https://bcr.bazel.build/modules/platforms/0.0.7/MODULE.bazel": "72fd4a0ede9ee5c021f6a8dd92b503e089f46c227ba2813ff183b71616034814", + "https://bcr.bazel.build/modules/platforms/0.0.8/MODULE.bazel": "9f142c03e348f6d263719f5074b21ef3adf0b139ee4c5133e2aa35664da9eb2d", + "https://bcr.bazel.build/modules/protobuf/21.7/MODULE.bazel": "a5a29bb89544f9b97edce05642fac225a808b5b7be74038ea3640fae2f8e66a7", + "https://bcr.bazel.build/modules/protobuf/27.0/MODULE.bazel": "7873b60be88844a0a1d8f80b9d5d20cfbd8495a689b8763e76c6372998d3f64c", + "https://bcr.bazel.build/modules/protobuf/27.1/MODULE.bazel": "703a7b614728bb06647f965264967a8ef1c39e09e8f167b3ca0bb1fd80449c0d", + "https://bcr.bazel.build/modules/protobuf/29.0-rc2/MODULE.bazel": "6241d35983510143049943fc0d57937937122baf1b287862f9dc8590fc4c37df", + "https://bcr.bazel.build/modules/protobuf/29.0-rc3/MODULE.bazel": "33c2dfa286578573afc55a7acaea3cada4122b9631007c594bf0729f41c8de92", + "https://bcr.bazel.build/modules/protobuf/29.0/MODULE.bazel": "319dc8bf4c679ff87e71b1ccfb5a6e90a6dbc4693501d471f48662ac46d04e4e", + "https://bcr.bazel.build/modules/protobuf/29.0/source.json": "b857f93c796750eef95f0d61ee378f3420d00ee1dd38627b27193aa482f4f981", + "https://bcr.bazel.build/modules/protobuf/3.19.0/MODULE.bazel": "6b5fbb433f760a99a22b18b6850ed5784ef0e9928a72668b66e4d7ccd47db9b0", + "https://bcr.bazel.build/modules/protobuf/3.19.2/MODULE.bazel": "532ffe5f2186b69fdde039efe6df13ba726ff338c6bc82275ad433013fa10573", + "https://bcr.bazel.build/modules/protobuf/3.19.6/MODULE.bazel": "9233edc5e1f2ee276a60de3eaa47ac4132302ef9643238f23128fea53ea12858", + "https://bcr.bazel.build/modules/pybind11_bazel/2.11.1/MODULE.bazel": "88af1c246226d87e65be78ed49ecd1e6f5e98648558c14ce99176da041dc378e", + "https://bcr.bazel.build/modules/pybind11_bazel/2.11.1/source.json": "be4789e951dd5301282729fe3d4938995dc4c1a81c2ff150afc9f1b0504c6022", + "https://bcr.bazel.build/modules/re2/2023-09-01/MODULE.bazel": "cb3d511531b16cfc78a225a9e2136007a48cf8a677e4264baeab57fe78a80206", + "https://bcr.bazel.build/modules/re2/2023-09-01/source.json": "e044ce89c2883cd957a2969a43e79f7752f9656f6b20050b62f90ede21ec6eb4", + "https://bcr.bazel.build/modules/rules_android/0.1.1/MODULE.bazel": "48809ab0091b07ad0182defb787c4c5328bd3a278938415c00a7b69b50c4d3a8", + "https://bcr.bazel.build/modules/rules_android/0.1.1/source.json": "e6986b41626ee10bdc864937ffb6d6bf275bb5b9c65120e6137d56e6331f089e", + "https://bcr.bazel.build/modules/rules_bazel_integration_test/0.27.0/MODULE.bazel": "66b85a47d4aa51686c3e43befc7442b5be84415b12296954929ba199d46823be", + "https://bcr.bazel.build/modules/rules_bazel_integration_test/0.27.0/source.json": "28bd34e4cbbe78a826aa513cf555d9cb52f0fe589b64d20ca812b8e3fbca572f", + "https://bcr.bazel.build/modules/rules_cc/0.0.1/MODULE.bazel": "cb2aa0747f84c6c3a78dad4e2049c154f08ab9d166b1273835a8174940365647", + "https://bcr.bazel.build/modules/rules_cc/0.0.10/MODULE.bazel": "ec1705118f7eaedd6e118508d3d26deba2a4e76476ada7e0e3965211be012002", + "https://bcr.bazel.build/modules/rules_cc/0.0.13/MODULE.bazel": "0e8529ed7b323dad0775ff924d2ae5af7640b23553dfcd4d34344c7e7a867191", + "https://bcr.bazel.build/modules/rules_cc/0.0.15/MODULE.bazel": "6704c35f7b4a72502ee81f61bf88706b54f06b3cbe5558ac17e2e14666cd5dcc", + "https://bcr.bazel.build/modules/rules_cc/0.0.16/MODULE.bazel": "7661303b8fc1b4d7f532e54e9d6565771fea666fbdf839e0a86affcd02defe87", + "https://bcr.bazel.build/modules/rules_cc/0.0.17/MODULE.bazel": "2ae1d8f4238ec67d7185d8861cb0a2cdf4bc608697c331b95bf990e69b62e64a", + "https://bcr.bazel.build/modules/rules_cc/0.0.17/source.json": "4db99b3f55c90ab28d14552aa0632533e3e8e5e9aea0f5c24ac0014282c2a7c5", + "https://bcr.bazel.build/modules/rules_cc/0.0.2/MODULE.bazel": "6915987c90970493ab97393024c156ea8fb9f3bea953b2f3ec05c34f19b5695c", + "https://bcr.bazel.build/modules/rules_cc/0.0.6/MODULE.bazel": "abf360251023dfe3efcef65ab9d56beefa8394d4176dd29529750e1c57eaa33f", + "https://bcr.bazel.build/modules/rules_cc/0.0.8/MODULE.bazel": "964c85c82cfeb6f3855e6a07054fdb159aced38e99a5eecf7bce9d53990afa3e", + "https://bcr.bazel.build/modules/rules_cc/0.0.9/MODULE.bazel": "836e76439f354b89afe6a911a7adf59a6b2518fafb174483ad78a2a2fde7b1c5", + "https://bcr.bazel.build/modules/rules_foreign_cc/0.9.0/MODULE.bazel": "c9e8c682bf75b0e7c704166d79b599f93b72cfca5ad7477df596947891feeef6", + "https://bcr.bazel.build/modules/rules_fuzzing/0.5.2/MODULE.bazel": "40c97d1144356f52905566c55811f13b299453a14ac7769dfba2ac38192337a8", + "https://bcr.bazel.build/modules/rules_fuzzing/0.5.2/source.json": "c8b1e2c717646f1702290959a3302a178fb639d987ab61d548105019f11e527e", + "https://bcr.bazel.build/modules/rules_go/0.41.0/MODULE.bazel": "55861d8e8bb0e62cbd2896f60ff303f62ffcb0eddb74ecb0e5c0cbe36fc292c8", + "https://bcr.bazel.build/modules/rules_go/0.42.0/MODULE.bazel": "8cfa875b9aa8c6fce2b2e5925e73c1388173ea3c32a0db4d2b4804b453c14270", + "https://bcr.bazel.build/modules/rules_go/0.46.0/MODULE.bazel": "3477df8bdcc49e698b9d25f734c4f3a9f5931ff34ee48a2c662be168f5f2d3fd", + "https://bcr.bazel.build/modules/rules_go/0.50.1/MODULE.bazel": "b91a308dc5782bb0a8021ad4330c81fea5bda77f96b9e4c117b9b9c8f6665ee0", + "https://bcr.bazel.build/modules/rules_go/0.50.1/source.json": "205765fd30216c70321f84c9a967267684bdc74350af3f3c46c857d9f80a4fa2", + "https://bcr.bazel.build/modules/rules_java/4.0.0/MODULE.bazel": "5a78a7ae82cd1a33cef56dc578c7d2a46ed0dca12643ee45edbb8417899e6f74", + "https://bcr.bazel.build/modules/rules_java/5.3.5/MODULE.bazel": "a4ec4f2db570171e3e5eb753276ee4b389bae16b96207e9d3230895c99644b86", + "https://bcr.bazel.build/modules/rules_java/6.0.0/MODULE.bazel": "8a43b7df601a7ec1af61d79345c17b31ea1fedc6711fd4abfd013ea612978e39", + "https://bcr.bazel.build/modules/rules_java/6.5.2/MODULE.bazel": "1d440d262d0e08453fa0c4d8f699ba81609ed0e9a9a0f02cd10b3e7942e61e31", + "https://bcr.bazel.build/modules/rules_java/7.10.0/MODULE.bazel": "530c3beb3067e870561739f1144329a21c851ff771cd752a49e06e3dc9c2e71a", + "https://bcr.bazel.build/modules/rules_java/7.12.2/MODULE.bazel": "579c505165ee757a4280ef83cda0150eea193eed3bef50b1004ba88b99da6de6", + "https://bcr.bazel.build/modules/rules_java/7.2.0/MODULE.bazel": "06c0334c9be61e6cef2c8c84a7800cef502063269a5af25ceb100b192453d4ab", + "https://bcr.bazel.build/modules/rules_java/7.6.1/MODULE.bazel": "2f14b7e8a1aa2f67ae92bc69d1ec0fa8d9f827c4e17ff5e5f02e91caa3b2d0fe", + "https://bcr.bazel.build/modules/rules_java/8.3.2/MODULE.bazel": "7336d5511ad5af0b8615fdc7477535a2e4e723a357b6713af439fe8cf0195017", + "https://bcr.bazel.build/modules/rules_java/8.5.1/MODULE.bazel": "d8a9e38cc5228881f7055a6079f6f7821a073df3744d441978e7a43e20226939", + "https://bcr.bazel.build/modules/rules_java/8.6.1/MODULE.bazel": "f4808e2ab5b0197f094cabce9f4b006a27766beb6a9975931da07099560ca9c2", + "https://bcr.bazel.build/modules/rules_java/8.6.1/source.json": "f18d9ad3c4c54945bf422ad584fa6c5ca5b3116ff55a5b1bc77e5c1210be5960", + "https://bcr.bazel.build/modules/rules_jvm_external/4.4.2/MODULE.bazel": "a56b85e418c83eb1839819f0b515c431010160383306d13ec21959ac412d2fe7", + "https://bcr.bazel.build/modules/rules_jvm_external/5.1/MODULE.bazel": "33f6f999e03183f7d088c9be518a63467dfd0be94a11d0055fe2d210f89aa909", + "https://bcr.bazel.build/modules/rules_jvm_external/5.2/MODULE.bazel": "d9351ba35217ad0de03816ef3ed63f89d411349353077348a45348b096615036", + "https://bcr.bazel.build/modules/rules_jvm_external/6.3/MODULE.bazel": "c998e060b85f71e00de5ec552019347c8bca255062c990ac02d051bb80a38df0", + "https://bcr.bazel.build/modules/rules_jvm_external/6.3/source.json": "6f5f5a5a4419ae4e37c35a5bb0a6ae657ed40b7abc5a5189111b47fcebe43197", + "https://bcr.bazel.build/modules/rules_kotlin/1.9.6/MODULE.bazel": "d269a01a18ee74d0335450b10f62c9ed81f2321d7958a2934e44272fe82dcef3", + "https://bcr.bazel.build/modules/rules_kotlin/1.9.6/source.json": "2faa4794364282db7c06600b7e5e34867a564ae91bda7cae7c29c64e9466b7d5", + "https://bcr.bazel.build/modules/rules_license/0.0.3/MODULE.bazel": "627e9ab0247f7d1e05736b59dbb1b6871373de5ad31c3011880b4133cafd4bd0", + "https://bcr.bazel.build/modules/rules_license/0.0.4/MODULE.bazel": "6a88dd22800cf1f9f79ba32cacad0d3a423ed28efa2c2ed5582eaa78dd3ac1e5", + "https://bcr.bazel.build/modules/rules_license/0.0.7/MODULE.bazel": "088fbeb0b6a419005b89cf93fe62d9517c0a2b8bb56af3244af65ecfe37e7d5d", + "https://bcr.bazel.build/modules/rules_license/1.0.0/MODULE.bazel": "a7fda60eefdf3d8c827262ba499957e4df06f659330bbe6cdbdb975b768bb65c", + "https://bcr.bazel.build/modules/rules_license/1.0.0/source.json": "a52c89e54cc311196e478f8382df91c15f7a2bfdf4c6cd0e2675cc2ff0b56efb", + "https://bcr.bazel.build/modules/rules_multirun/0.9.0/MODULE.bazel": "32d628ef586b5b23f67e55886b7bc38913ea4160420d66ae90521dda2ff37df0", + "https://bcr.bazel.build/modules/rules_multirun/0.9.0/source.json": "e882ba77962fa6c5fe68619e5c7d0374ec9a219fb8d03c42eadaf6d0243771bd", + "https://bcr.bazel.build/modules/rules_pkg/0.7.0/MODULE.bazel": "df99f03fc7934a4737122518bb87e667e62d780b610910f0447665a7e2be62dc", + "https://bcr.bazel.build/modules/rules_pkg/1.0.1/MODULE.bazel": "5b1df97dbc29623bccdf2b0dcd0f5cb08e2f2c9050aab1092fd39a41e82686ff", + "https://bcr.bazel.build/modules/rules_pkg/1.0.1/source.json": "bd82e5d7b9ce2d31e380dd9f50c111d678c3bdaca190cb76b0e1c71b05e1ba8a", + "https://bcr.bazel.build/modules/rules_proto/4.0.0/MODULE.bazel": "a7a7b6ce9bee418c1a760b3d84f83a299ad6952f9903c67f19e4edd964894e06", + "https://bcr.bazel.build/modules/rules_proto/5.3.0-21.7/MODULE.bazel": "e8dff86b0971688790ae75528fe1813f71809b5afd57facb44dad9e8eca631b7", + "https://bcr.bazel.build/modules/rules_proto/6.0.0/MODULE.bazel": "b531d7f09f58dce456cd61b4579ce8c86b38544da75184eadaf0a7cb7966453f", + "https://bcr.bazel.build/modules/rules_proto/6.0.2/MODULE.bazel": "ce916b775a62b90b61888052a416ccdda405212b6aaeb39522f7dc53431a5e73", + "https://bcr.bazel.build/modules/rules_proto/7.0.2/MODULE.bazel": "bf81793bd6d2ad89a37a40693e56c61b0ee30f7a7fdbaf3eabbf5f39de47dea2", + "https://bcr.bazel.build/modules/rules_proto/7.0.2/source.json": "1e5e7260ae32ef4f2b52fd1d0de8d03b606a44c91b694d2f1afb1d3b28a48ce1", + "https://bcr.bazel.build/modules/rules_shell/0.2.0/MODULE.bazel": "fda8a652ab3c7d8fee214de05e7a9916d8b28082234e8d2c0094505c5268ed3c", + "https://bcr.bazel.build/modules/rules_shell/0.3.0/MODULE.bazel": "de4402cd12f4cc8fda2354fce179fdb068c0b9ca1ec2d2b17b3e21b24c1a937b", + "https://bcr.bazel.build/modules/rules_shell/0.3.0/source.json": "c55ed591aa5009401ddf80ded9762ac32c358d2517ee7820be981e2de9756cf3", + "https://bcr.bazel.build/modules/rules_testing/0.6.0/MODULE.bazel": "8518d53bc742c462536d3f1a0de0c265bd7b51f32797fea4132007223ed2926f", + "https://bcr.bazel.build/modules/rules_testing/0.6.0/source.json": "915ae13ae2247c986cc57289f21e7f1d9711cd2ecfdf5867b51dc0484f3b043b", + "https://bcr.bazel.build/modules/stardoc/0.5.1/MODULE.bazel": "1a05d92974d0c122f5ccf09291442580317cdd859f07a8655f1db9a60374f9f8", + "https://bcr.bazel.build/modules/stardoc/0.5.3/MODULE.bazel": "c7f6948dae6999bf0db32c1858ae345f112cacf98f174c7a8bb707e41b974f1c", + "https://bcr.bazel.build/modules/stardoc/0.5.6/MODULE.bazel": "c43dabc564990eeab55e25ed61c07a1aadafe9ece96a4efabb3f8bf9063b71ef", + "https://bcr.bazel.build/modules/stardoc/0.7.0/MODULE.bazel": "05e3d6d30c099b6770e97da986c53bd31844d7f13d41412480ea265ac9e8079c", + "https://bcr.bazel.build/modules/stardoc/0.7.2/MODULE.bazel": "fc152419aa2ea0f51c29583fab1e8c99ddefd5b3778421845606ee628629e0e5", + "https://bcr.bazel.build/modules/stardoc/0.7.2/source.json": "58b029e5e901d6802967754adf0a9056747e8176f017cfe3607c0851f4d42216", + "https://bcr.bazel.build/modules/upb/0.0.0-20220923-a547704/MODULE.bazel": "7298990c00040a0e2f121f6c32544bab27d4452f80d9ce51349b1a28f3005c43", + "https://bcr.bazel.build/modules/zlib/1.2.11/MODULE.bazel": "07b389abc85fdbca459b69e2ec656ae5622873af3f845e1c9d80fe179f3effa0", + "https://bcr.bazel.build/modules/zlib/1.2.12/MODULE.bazel": "3b1a8834ada2a883674be8cbd36ede1b6ec481477ada359cd2d3ddc562340b27", + "https://bcr.bazel.build/modules/zlib/1.3.1.bcr.3/MODULE.bazel": "af322bc08976524477c79d1e45e241b6efbeb918c497e8840b8ab116802dda79", + "https://bcr.bazel.build/modules/zlib/1.3.1.bcr.3/source.json": "2be409ac3c7601245958cd4fcdff4288be79ed23bd690b4b951f500d54ee6e7d", + "https://bcr.bazel.build/modules/zlib/1.3.1/MODULE.bazel": "751c9940dcfe869f5f7274e1295422a34623555916eb98c174c1e945594bf198" + }, + "selectedYankedVersions": {}, + "moduleExtensions": { + "//python/extensions:pip.bzl%pip": { + "general": { + "bzlTransitiveDigest": "wLC8ZJWm/oKERWSJ53dCg6RKNEOh6HUrDJ9CAzOwVYs=", + "usagesDigest": "YlSFe2ItKSPNZPX8lwGeHExgU3q/r1fVYnFieVD4qmQ=", + "recordedFileInputs": { + "@@//docs/requirements.txt": "4b7f6f5e699049343db70f8bda0c2b97be9fd9b1b3c117a2b624dc633ba944a5", + "@@//examples/wheel/requirements_server.txt": "981e09e454aa31d72f73f369436fce488e5a478717a8fac808412f4695e44823", + "@@//tools/publish/requirements_darwin.txt": "095d4a4f3d639dce831cd493367631cd51b53665292ab20194bac2c0c6458fa8", + "@@//tools/publish/requirements_linux.txt": "d576e0d8542df61396a9b38deeaa183c24135ed5e8e73bb9622f298f2671811e", + "@@//tools/publish/requirements_windows.txt": "d18538a3982beab378fd5687f4db33162ee1ece69801f9a451661b1b64286b76", + "@@protobuf+//python/requirements.txt": "983be60d3cec4b319dcab6d48aeb3f5b2f7c3350f26b3a9e97486c37967c73c5", + "@@rules_fuzzing+//fuzzing/requirements.txt": "ab04664be026b632a0d2a2446c4f65982b7654f5b6851d2f9d399a19b7242a5b" + }, + "recordedDirentsInputs": {}, + "envVariables": { + "RULES_PYTHON_REPO_DEBUG": null, + "RULES_PYTHON_REPO_DEBUG_VERBOSITY": null + }, + "generatedRepoSpecs": { + "dev_pip_311_absl_py_py3_none_any_526a04ea": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "absl_py-2.1.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "absl-py==2.1.0", + "sha256": "526a04eadab8b4ee719ce68f204172ead1027549089702d99b9059f129ff1308", + "urls": [ + "https://files.pythonhosted.org/packages/a2/ad/e0d3c824784ff121c03cc031f944bc7e139a8f1870ffd2845cc2dd76f6c4/absl_py-2.1.0-py3-none-any.whl" + ] + } + }, + "dev_pip_311_alabaster_py3_none_any_fc678640": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "alabaster-1.0.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "alabaster==1.0.0", + "sha256": "fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", + "urls": [ + "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl" + ] + } + }, + "dev_pip_311_astroid_py3_none_any_db676dc4": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "astroid-3.3.6-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "astroid==3.3.6", + "sha256": "db676dc4f3ae6bfe31cda227dc60e03438378d7a896aec57422c95634e8d722f", + "urls": [ + "https://files.pythonhosted.org/packages/0c/d2/82c8ccef22ea873a2b0da9636e47d45137eeeb2fb9320c5dbbdd3627bab0/astroid-3.3.6-py3-none-any.whl" + ] + } + }, + "dev_pip_311_babel_py3_none_any_368b5b98": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "babel-2.16.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "babel==2.16.0", + "sha256": "368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b", + "urls": [ + "https://files.pythonhosted.org/packages/ed/20/bc79bc575ba2e2a7f70e8a1155618bb1301eaa5132a8271373a6903f73f8/babel-2.16.0-py3-none-any.whl" + ] + } + }, + "dev_pip_311_certifi_py3_none_any_922820b5": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "certifi-2024.8.30-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "certifi==2024.8.30", + "sha256": "922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8", + "urls": [ + "https://files.pythonhosted.org/packages/12/90/3c9ff0512038035f59d279fddeb79f5f1eccd8859f06d6163c58798b9487/certifi-2024.8.30-py3-none-any.whl" + ] + } + }, + "dev_pip_311_charset_normalizer_cp311_cp311_macosx_10_9_universal2_0d99dd8f": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "0d99dd8ff461990f12d6e42c7347fd9ab2532fb70e9621ba520f9e8637161d7c", + "urls": [ + "https://files.pythonhosted.org/packages/9c/61/73589dcc7a719582bf56aae309b6103d2762b526bffe189d635a7fcfd998/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl" + ] + } + }, + "dev_pip_311_charset_normalizer_cp311_cp311_macosx_10_9_x86_64_c57516e5": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "c57516e58fd17d03ebe67e181a4e4e2ccab1168f8c2976c6a334d4f819fe5944", + "urls": [ + "https://files.pythonhosted.org/packages/77/d5/8c982d58144de49f59571f940e329ad6e8615e1e82ef84584c5eeb5e1d72/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl" + ] + } + }, + "dev_pip_311_charset_normalizer_cp311_cp311_macosx_11_0_arm64_6dba5d19": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "6dba5d19c4dfab08e58d5b36304b3f92f3bd5d42c1a3fa37b5ba5cdf6dfcbcee", + "urls": [ + "https://files.pythonhosted.org/packages/bf/19/411a64f01ee971bed3231111b69eb56f9331a769072de479eae7de52296d/charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl" + ] + } + }, + "dev_pip_311_charset_normalizer_cp311_cp311_manylinux_2_17_aarch64_bf4475b8": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "bf4475b82be41b07cc5e5ff94810e6a01f276e37c2d55571e3fe175e467a1a1c", + "urls": [ + "https://files.pythonhosted.org/packages/4c/92/97509850f0d00e9f14a46bc751daabd0ad7765cff29cdfb66c68b6dad57f/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" + ] + } + }, + "dev_pip_311_charset_normalizer_cp311_cp311_manylinux_2_17_ppc64le_ce031db0": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "ce031db0408e487fd2775d745ce30a7cd2923667cf3b69d48d219f1d8f5ddeb6", + "urls": [ + "https://files.pythonhosted.org/packages/e2/29/d227805bff72ed6d6cb1ce08eec707f7cfbd9868044893617eb331f16295/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl" + ] + } + }, + "dev_pip_311_charset_normalizer_cp311_cp311_manylinux_2_17_s390x_8ff4e7cd": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "8ff4e7cdfdb1ab5698e675ca622e72d58a6fa2a8aa58195de0c0061288e6e3ea", + "urls": [ + "https://files.pythonhosted.org/packages/13/bc/87c2c9f2c144bedfa62f894c3007cd4530ba4b5351acb10dc786428a50f0/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl" + ] + } + }, + "dev_pip_311_charset_normalizer_cp311_cp311_manylinux_2_17_x86_64_3710a975": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "3710a9751938947e6327ea9f3ea6332a09bf0ba0c09cae9cb1f250bd1f1549bc", + "urls": [ + "https://files.pythonhosted.org/packages/eb/5b/6f10bad0f6461fa272bfbbdf5d0023b5fb9bc6217c92bf068fa5a99820f5/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" + ] + } + }, + "dev_pip_311_charset_normalizer_cp311_cp311_musllinux_1_2_aarch64_47334db7": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "47334db71978b23ebcf3c0f9f5ee98b8d65992b65c9c4f2d34c2eaf5bcaf0594", + "urls": [ + "https://files.pythonhosted.org/packages/d7/a1/493919799446464ed0299c8eef3c3fad0daf1c3cd48bff9263c731b0d9e2/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl" + ] + } + }, + "dev_pip_311_charset_normalizer_cp311_cp311_musllinux_1_2_ppc64le_f1a2f519": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "f1a2f519ae173b5b6a2c9d5fa3116ce16e48b3462c8b96dfdded11055e3d6365", + "urls": [ + "https://files.pythonhosted.org/packages/75/d2/0ab54463d3410709c09266dfb416d032a08f97fd7d60e94b8c6ef54ae14b/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl" + ] + } + }, + "dev_pip_311_charset_normalizer_cp311_cp311_musllinux_1_2_s390x_63bc5c4a": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "63bc5c4ae26e4bc6be6469943b8253c0fd4e4186c43ad46e713ea61a0ba49129", + "urls": [ + "https://files.pythonhosted.org/packages/8d/c9/27e41d481557be53d51e60750b85aa40eaf52b841946b3cdeff363105737/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl" + ] + } + }, + "dev_pip_311_charset_normalizer_cp311_cp311_musllinux_1_2_x86_64_bcb4f8ea": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "bcb4f8ea87d03bc51ad04add8ceaf9b0f085ac045ab4d74e73bbc2dc033f0236", + "urls": [ + "https://files.pythonhosted.org/packages/ee/44/4f62042ca8cdc0cabf87c0fc00ae27cd8b53ab68be3605ba6d071f742ad3/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl" + ] + } + }, + "dev_pip_311_charset_normalizer_cp311_cp311_win_amd64_cee4373f": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "cee4373f4d3ad28f1ab6290684d8e2ebdb9e7a1b74fdc39e4c211995f77bec27", + "urls": [ + "https://files.pythonhosted.org/packages/0b/6e/b13bd47fa9023b3699e94abf565b5a2f0b0be6e9ddac9812182596ee62e4/charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl" + ] + } + }, + "dev_pip_311_charset_normalizer_py3_none_any_fe9f97fe": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "fe9f97feb71aa9896b81973a7bbada8c49501dc73e58a10fcef6663af95e5079", + "urls": [ + "https://files.pythonhosted.org/packages/bf/9b/08c0432272d77b04803958a4598a51e2a4b51c06640af8b8f0f908c18bf2/charset_normalizer-3.4.0-py3-none-any.whl" + ] + } + }, + "dev_pip_311_colorama_py2_none_any_4f1d9991": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_windows_x86_64" + ], + "filename": "colorama-0.4.6-py2.py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "colorama==0.4.6", + "sha256": "4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", + "urls": [ + "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl" + ] + } + }, + "dev_pip_311_docutils_py3_none_any_dafca5b9": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "docutils-0.21.2-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "docutils==0.21.2", + "sha256": "dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2", + "urls": [ + "https://files.pythonhosted.org/packages/8f/d7/9322c609343d929e75e7e5e6255e614fcc67572cfd083959cdef3b7aad79/docutils-0.21.2-py3-none-any.whl" + ] + } + }, + "dev_pip_311_idna_py3_none_any_946d195a": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "idna-3.10-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "idna==3.10", + "sha256": "946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", + "urls": [ + "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl" + ] + } + }, + "dev_pip_311_imagesize_py2_none_any_0d8d18d0": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "imagesize-1.4.1-py2.py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "imagesize==1.4.1", + "sha256": "0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b", + "urls": [ + "https://files.pythonhosted.org/packages/ff/62/85c4c919272577931d407be5ba5d71c20f0b616d31a0befe0ae45bb79abd/imagesize-1.4.1-py2.py3-none-any.whl" + ] + } + }, + "dev_pip_311_jinja2_py3_none_any_bc5dd2ab": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "jinja2-3.1.4-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "jinja2==3.1.4", + "sha256": "bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d", + "urls": [ + "https://files.pythonhosted.org/packages/31/80/3a54838c3fb461f6fec263ebf3a3a41771bd05190238de3486aae8540c36/jinja2-3.1.4-py3-none-any.whl" + ] + } + }, + "dev_pip_311_markdown_it_py_py3_none_any_35521684": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "markdown_it_py-3.0.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "markdown-it-py==3.0.0", + "sha256": "355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", + "urls": [ + "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl" + ] + } + }, + "dev_pip_311_markupsafe_cp311_cp311_macosx_10_9_universal2_9025b401": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "markupsafe==3.0.2", + "sha256": "9025b4018f3a1314059769c7bf15441064b2207cb3f065e6ea1e7359cb46db9d", + "urls": [ + "https://files.pythonhosted.org/packages/6b/28/bbf83e3f76936960b850435576dd5e67034e200469571be53f69174a2dfd/MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl" + ] + } + }, + "dev_pip_311_markupsafe_cp311_cp311_macosx_11_0_arm64_93335ca3": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "markupsafe==3.0.2", + "sha256": "93335ca3812df2f366e80509ae119189886b0f3c2b81325d39efdb84a1e2ae93", + "urls": [ + "https://files.pythonhosted.org/packages/6c/30/316d194b093cde57d448a4c3209f22e3046c5bb2fb0820b118292b334be7/MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl" + ] + } + }, + "dev_pip_311_markupsafe_cp311_cp311_manylinux_2_17_aarch64_2cb8438c": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "markupsafe==3.0.2", + "sha256": "2cb8438c3cbb25e220c2ab33bb226559e7afb3baec11c4f218ffa7308603c832", + "urls": [ + "https://files.pythonhosted.org/packages/f2/96/9cdafba8445d3a53cae530aaf83c38ec64c4d5427d975c974084af5bc5d2/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" + ] + } + }, + "dev_pip_311_markupsafe_cp311_cp311_manylinux_2_17_x86_64_a123e330": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "markupsafe==3.0.2", + "sha256": "a123e330ef0853c6e822384873bef7507557d8e4a082961e1defa947aa59ba84", + "urls": [ + "https://files.pythonhosted.org/packages/f1/a4/aefb044a2cd8d7334c8a47d3fb2c9f328ac48cb349468cc31c20b539305f/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" + ] + } + }, + "dev_pip_311_markupsafe_cp311_cp311_musllinux_1_2_aarch64_d8213e09": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "markupsafe==3.0.2", + "sha256": "d8213e09c917a951de9d09ecee036d5c7d36cb6cb7dbaece4c71a60d79fb9798", + "urls": [ + "https://files.pythonhosted.org/packages/00/7b/e92c64e079b2d0d7ddf69899c98842f3f9a60a1ae72657c89ce2655c999d/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl" + ] + } + }, + "dev_pip_311_markupsafe_cp311_cp311_musllinux_1_2_x86_64_0bff5e0a": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "markupsafe==3.0.2", + "sha256": "0bff5e0ae4ef2e1ae4fdf2dfd5b76c75e5c2fa4132d05fc1b0dabcd20c7e28c4", + "urls": [ + "https://files.pythonhosted.org/packages/69/84/83439e16197337b8b14b6a5b9c2105fff81d42c2a7c5b58ac7b62ee2c3b1/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl" + ] + } + }, + "dev_pip_311_markupsafe_cp311_cp311_win_amd64_70a87b41": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "markupsafe==3.0.2", + "sha256": "70a87b411535ccad5ef2f1df5136506a10775d267e197e4cf531ced10537bd6b", + "urls": [ + "https://files.pythonhosted.org/packages/da/b8/3a3bd761922d416f3dc5d00bfbed11f66b1ab89a0c2b6e887240a30b0f6b/MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl" + ] + } + }, + "dev_pip_311_mdit_py_plugins_py3_none_any_0c673c3f": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "mdit_py_plugins-0.4.2-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "mdit-py-plugins==0.4.2", + "sha256": "0c673c3f889399a33b95e88d2f0d111b4447bdfea7f237dab2d488f459835636", + "urls": [ + "https://files.pythonhosted.org/packages/a7/f7/7782a043553ee469c1ff49cfa1cdace2d6bf99a1f333cf38676b3ddf30da/mdit_py_plugins-0.4.2-py3-none-any.whl" + ] + } + }, + "dev_pip_311_mdurl_py3_none_any_84008a41": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "mdurl-0.1.2-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "mdurl==0.1.2", + "sha256": "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", + "urls": [ + "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl" + ] + } + }, + "dev_pip_311_myst_parser_py3_none_any_b9317997": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "myst_parser-4.0.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "myst-parser==4.0.0", + "sha256": "b9317997552424448c6096c2558872fdb6f81d3ecb3a40ce84a7518798f3f28d", + "urls": [ + "https://files.pythonhosted.org/packages/ca/b4/b036f8fdb667587bb37df29dc6644681dd78b7a2a6321a34684b79412b28/myst_parser-4.0.0-py3-none-any.whl" + ] + } + }, + "dev_pip_311_packaging_py3_none_any_5b8f2217": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "packaging-24.1-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "packaging==24.1", + "sha256": "5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124", + "urls": [ + "https://files.pythonhosted.org/packages/08/aa/cc0199a5f0ad350994d660967a8efb233fe0416e4639146c089643407ce6/packaging-24.1-py3-none-any.whl" + ] + } + }, + "dev_pip_311_pygments_py3_none_any_b8e6aca0": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "pygments-2.18.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "pygments==2.18.0", + "sha256": "b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a", + "urls": [ + "https://files.pythonhosted.org/packages/f7/3f/01c8b82017c199075f8f788d0d906b9ffbbc5a47dc9918a945e13d5a2bda/pygments-2.18.0-py3-none-any.whl" + ] + } + }, + "dev_pip_311_pyyaml_cp311_cp311_macosx_10_9_x86_64_cc1c1159": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "pyyaml==6.0.2", + "sha256": "cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774", + "urls": [ + "https://files.pythonhosted.org/packages/f8/aa/7af4e81f7acba21a4c6be026da38fd2b872ca46226673c89a758ebdc4fd2/PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl" + ] + } + }, + "dev_pip_311_pyyaml_cp311_cp311_macosx_11_0_arm64_1e2120ef": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "pyyaml==6.0.2", + "sha256": "1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee", + "urls": [ + "https://files.pythonhosted.org/packages/8b/62/b9faa998fd185f65c1371643678e4d58254add437edb764a08c5a98fb986/PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl" + ] + } + }, + "dev_pip_311_pyyaml_cp311_cp311_manylinux_2_17_aarch64_5d225db5": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "pyyaml==6.0.2", + "sha256": "5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c", + "urls": [ + "https://files.pythonhosted.org/packages/ad/0c/c804f5f922a9a6563bab712d8dcc70251e8af811fce4524d57c2c0fd49a4/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" + ] + } + }, + "dev_pip_311_pyyaml_cp311_cp311_manylinux_2_17_s390x_5ac9328e": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "pyyaml==6.0.2", + "sha256": "5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317", + "urls": [ + "https://files.pythonhosted.org/packages/51/16/6af8d6a6b210c8e54f1406a6b9481febf9c64a3109c541567e35a49aa2e7/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl" + ] + } + }, + "dev_pip_311_pyyaml_cp311_cp311_manylinux_2_17_x86_64_3ad2a3de": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "pyyaml==6.0.2", + "sha256": "3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85", + "urls": [ + "https://files.pythonhosted.org/packages/75/e4/2c27590dfc9992f73aabbeb9241ae20220bd9452df27483b6e56d3975cc5/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" + ] + } + }, + "dev_pip_311_pyyaml_cp311_cp311_musllinux_1_1_aarch64_ff3824dc": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "pyyaml==6.0.2", + "sha256": "ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4", + "urls": [ + "https://files.pythonhosted.org/packages/9b/97/ecc1abf4a823f5ac61941a9c00fe501b02ac3ab0e373c3857f7d4b83e2b6/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl" + ] + } + }, + "dev_pip_311_pyyaml_cp311_cp311_musllinux_1_1_x86_64_797b4f72": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "pyyaml==6.0.2", + "sha256": "797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e", + "urls": [ + "https://files.pythonhosted.org/packages/45/73/0f49dacd6e82c9430e46f4a027baa4ca205e8b0a9dce1397f44edc23559d/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl" + ] + } + }, + "dev_pip_311_pyyaml_cp311_cp311_win_amd64_e10ce637": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "PyYAML-6.0.2-cp311-cp311-win_amd64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "pyyaml==6.0.2", + "sha256": "e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44", + "urls": [ + "https://files.pythonhosted.org/packages/ed/23/8da0bbe2ab9dcdd11f4f4557ccaf95c10b9811b13ecced089d43ce59c3c8/PyYAML-6.0.2-cp311-cp311-win_amd64.whl" + ] + } + }, + "dev_pip_311_readthedocs_sphinx_ext_py2_none_any_f8c56184": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "readthedocs_sphinx_ext-2.2.5-py2.py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "readthedocs-sphinx-ext==2.2.5", + "sha256": "f8c56184ea011c972dd45a90122568587cc85b0127bc9cf064d17c68bc809daa", + "urls": [ + "https://files.pythonhosted.org/packages/64/71/c89e7709a0d4f93af1848e9855112299a820b470d84f917b4dd5998bdd07/readthedocs_sphinx_ext-2.2.5-py2.py3-none-any.whl" + ] + } + }, + "dev_pip_311_requests_py3_none_any_70761cfe": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "requests-2.32.3-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "requests==2.32.3", + "sha256": "70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", + "urls": [ + "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl" + ] + } + }, + "dev_pip_311_snowballstemmer_py2_none_any_c8e1716e": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "snowballstemmer-2.2.0-py2.py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "snowballstemmer==2.2.0", + "sha256": "c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a", + "urls": [ + "https://files.pythonhosted.org/packages/ed/dc/c02e01294f7265e63a7315fe086dd1df7dacb9f840a804da846b96d01b96/snowballstemmer-2.2.0-py2.py3-none-any.whl" + ] + } + }, + "dev_pip_311_sphinx_autodoc2_py3_none_any_e867013b": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "sphinx_autodoc2-0.5.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "sphinx-autodoc2==0.5.0", + "sha256": "e867013b1512f9d6d7e6f6799f8b537d6884462acd118ef361f3f619a60b5c9e", + "urls": [ + "https://files.pythonhosted.org/packages/19/e6/48d47961bbdae755ba9c17dfc65d89356312c67668dcb36c87cfadfa1964/sphinx_autodoc2-0.5.0-py3-none-any.whl" + ] + } + }, + "dev_pip_311_sphinx_py3_none_any_09719015": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "sphinx-8.1.3-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "sphinx==8.1.3", + "sha256": "09719015511837b76bf6e03e42eb7595ac8c2e41eeb9c29c5b755c6b677992a2", + "urls": [ + "https://files.pythonhosted.org/packages/26/60/1ddff83a56d33aaf6f10ec8ce84b4c007d9368b21008876fceda7e7381ef/sphinx-8.1.3-py3-none-any.whl" + ] + } + }, + "dev_pip_311_sphinx_reredirects_py3_none_any_444ae143": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "sphinx_reredirects-0.1.5-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "sphinx-reredirects==0.1.5", + "sha256": "444ae1438fba4418242ca76d6a6de3eaee82aaf0d8f2b0cac71a15d32ce6eba2", + "urls": [ + "https://files.pythonhosted.org/packages/34/97/1f8143f87330f4c9ccc2c08ae9cd3cb1ce2944c51e98dd7ff141154fbcc7/sphinx_reredirects-0.1.5-py3-none-any.whl" + ] + } + }, + "dev_pip_311_sphinx_rtd_theme_py2_none_any_921c0ece": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "sphinx_rtd_theme-3.0.1-py2.py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "sphinx-rtd-theme==3.0.1", + "sha256": "921c0ece75e90633ee876bd7b148cfaad136b481907ad154ac3669b6fc957916", + "urls": [ + "https://files.pythonhosted.org/packages/c8/51/aed903ad0843a06ccfb93e6e8849e752a9379eaec0f50d9237ae373dd737/sphinx_rtd_theme-3.0.1-py2.py3-none-any.whl" + ] + } + }, + "dev_pip_311_sphinxcontrib_applehelp_py3_none_any_4cd3f0ec": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "sphinxcontrib-applehelp==2.0.0", + "sha256": "4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", + "urls": [ + "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl" + ] + } + }, + "dev_pip_311_sphinxcontrib_devhelp_py3_none_any_aefb8b83": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "sphinxcontrib-devhelp==2.0.0", + "sha256": "aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", + "urls": [ + "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl" + ] + } + }, + "dev_pip_311_sphinxcontrib_htmlhelp_py3_none_any_16675982": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "sphinxcontrib-htmlhelp==2.1.0", + "sha256": "166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", + "urls": [ + "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl" + ] + } + }, + "dev_pip_311_sphinxcontrib_jquery_py2_none_any_f936030d": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "sphinxcontrib_jquery-4.1-py2.py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "sphinxcontrib-jquery==4.1", + "sha256": "f936030d7d0147dd026a4f2b5a57343d233f1fc7b363f68b3d4f1cb0993878ae", + "urls": [ + "https://files.pythonhosted.org/packages/76/85/749bd22d1a68db7291c89e2ebca53f4306c3f205853cf31e9de279034c3c/sphinxcontrib_jquery-4.1-py2.py3-none-any.whl" + ] + } + }, + "dev_pip_311_sphinxcontrib_jsmath_py2_none_any_2ec2eaeb": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "sphinxcontrib-jsmath==1.0.1", + "sha256": "2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", + "urls": [ + "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl" + ] + } + }, + "dev_pip_311_sphinxcontrib_qthelp_py3_none_any_b18a828c": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "sphinxcontrib-qthelp==2.0.0", + "sha256": "b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", + "urls": [ + "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl" + ] + } + }, + "dev_pip_311_sphinxcontrib_serializinghtml_py3_none_any_6e2cb0ee": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "sphinxcontrib-serializinghtml==2.0.0", + "sha256": "6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", + "urls": [ + "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl" + ] + } + }, + "dev_pip_311_typing_extensions_py3_none_any_04e5ca03": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "typing_extensions-4.12.2-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "typing-extensions==4.12.2", + "sha256": "04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", + "urls": [ + "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl" + ] + } + }, + "dev_pip_311_urllib3_py3_none_any_ca899ca0": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "urllib3-2.2.3-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "dev_pip_311", + "requirement": "urllib3==2.2.3", + "sha256": "ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac", + "urls": [ + "https://files.pythonhosted.org/packages/ce/d9/5f4c13cecde62396b0d3fe530a50ccea91e7dfc1ccf0e09c228841bb5ba8/urllib3-2.2.3-py3-none-any.whl" + ] + } + }, + "dev_pip_313_absl_py_py3_none_any_526a04ea": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "absl_py-2.1.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "absl-py==2.1.0", + "sha256": "526a04eadab8b4ee719ce68f204172ead1027549089702d99b9059f129ff1308", + "urls": [ + "https://files.pythonhosted.org/packages/a2/ad/e0d3c824784ff121c03cc031f944bc7e139a8f1870ffd2845cc2dd76f6c4/absl_py-2.1.0-py3-none-any.whl" + ] + } + }, + "dev_pip_313_alabaster_py3_none_any_fc678640": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "alabaster-1.0.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "alabaster==1.0.0", + "sha256": "fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", + "urls": [ + "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl" + ] + } + }, + "dev_pip_313_astroid_py3_none_any_db676dc4": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "astroid-3.3.6-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "astroid==3.3.6", + "sha256": "db676dc4f3ae6bfe31cda227dc60e03438378d7a896aec57422c95634e8d722f", + "urls": [ + "https://files.pythonhosted.org/packages/0c/d2/82c8ccef22ea873a2b0da9636e47d45137eeeb2fb9320c5dbbdd3627bab0/astroid-3.3.6-py3-none-any.whl" + ] + } + }, + "dev_pip_313_babel_py3_none_any_368b5b98": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "babel-2.16.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "babel==2.16.0", + "sha256": "368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b", + "urls": [ + "https://files.pythonhosted.org/packages/ed/20/bc79bc575ba2e2a7f70e8a1155618bb1301eaa5132a8271373a6903f73f8/babel-2.16.0-py3-none-any.whl" + ] + } + }, + "dev_pip_313_certifi_py3_none_any_922820b5": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "certifi-2024.8.30-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "certifi==2024.8.30", + "sha256": "922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8", + "urls": [ + "https://files.pythonhosted.org/packages/12/90/3c9ff0512038035f59d279fddeb79f5f1eccd8859f06d6163c58798b9487/certifi-2024.8.30-py3-none-any.whl" + ] + } + }, + "dev_pip_313_charset_normalizer_cp313_cp313_macosx_10_13_universal2_dd4eda17": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_universal2.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "charset-normalizer==3.4.0", + "sha256": "dd4eda173a9fcccb5f2e2bd2a9f423d180194b1bf17cf59e3269899235b2a114", + "urls": [ + "https://files.pythonhosted.org/packages/f3/89/68a4c86f1a0002810a27f12e9a7b22feb198c59b2f05231349fbce5c06f4/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_universal2.whl" + ] + } + }, + "dev_pip_313_charset_normalizer_cp313_cp313_macosx_10_13_x86_64_e9e3c4c9": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "charset-normalizer==3.4.0", + "sha256": "e9e3c4c9e1ed40ea53acf11e2a386383c3304212c965773704e4603d589343ed", + "urls": [ + "https://files.pythonhosted.org/packages/4f/cd/8947fe425e2ab0aa57aceb7807af13a0e4162cd21eee42ef5b053447edf5/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_x86_64.whl" + ] + } + }, + "dev_pip_313_charset_normalizer_cp313_cp313_macosx_11_0_arm64_92a7e36b": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp313-cp313-macosx_11_0_arm64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "charset-normalizer==3.4.0", + "sha256": "92a7e36b000bf022ef3dbb9c46bfe2d52c047d5e3f3343f43204263c5addc250", + "urls": [ + "https://files.pythonhosted.org/packages/5b/f0/b5263e8668a4ee9becc2b451ed909e9c27058337fda5b8c49588183c267a/charset_normalizer-3.4.0-cp313-cp313-macosx_11_0_arm64.whl" + ] + } + }, + "dev_pip_313_charset_normalizer_cp313_cp313_manylinux_2_17_aarch64_54b6a92d": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "charset-normalizer==3.4.0", + "sha256": "54b6a92d009cbe2fb11054ba694bc9e284dad30a26757b1e372a1fdddaf21920", + "urls": [ + "https://files.pythonhosted.org/packages/ff/6e/e445afe4f7fda27a533f3234b627b3e515a1b9429bc981c9a5e2aa5d97b6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" + ] + } + }, + "dev_pip_313_charset_normalizer_cp313_cp313_manylinux_2_17_ppc64le_1ffd9493": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "charset-normalizer==3.4.0", + "sha256": "1ffd9493de4c922f2a38c2bf62b831dcec90ac673ed1ca182fe11b4d8e9f2a64", + "urls": [ + "https://files.pythonhosted.org/packages/a1/b2/4af9993b532d93270538ad4926c8e37dc29f2111c36f9c629840c57cd9b3/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl" + ] + } + }, + "dev_pip_313_charset_normalizer_cp313_cp313_manylinux_2_17_s390x_35c404d7": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "charset-normalizer==3.4.0", + "sha256": "35c404d74c2926d0287fbd63ed5d27eb911eb9e4a3bb2c6d294f3cfd4a9e0c23", + "urls": [ + "https://files.pythonhosted.org/packages/fb/6f/4e78c3b97686b871db9be6f31d64e9264e889f8c9d7ab33c771f847f79b7/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl" + ] + } + }, + "dev_pip_313_charset_normalizer_cp313_cp313_manylinux_2_17_x86_64_4796efc4": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "charset-normalizer==3.4.0", + "sha256": "4796efc4faf6b53a18e3d46343535caed491776a22af773f366534056c4e1fbc", + "urls": [ + "https://files.pythonhosted.org/packages/2b/c9/1c8fe3ce05d30c87eff498592c89015b19fade13df42850aafae09e94f35/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" + ] + } + }, + "dev_pip_313_charset_normalizer_cp313_cp313_musllinux_1_2_aarch64_92db3c28": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "charset-normalizer==3.4.0", + "sha256": "92db3c28b5b2a273346bebb24857fda45601aef6ae1c011c0a997106581e8a88", + "urls": [ + "https://files.pythonhosted.org/packages/0c/75/1ed813c3ffd200b1f3e71121c95da3f79e6d2a96120163443b3ad1057505/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_aarch64.whl" + ] + } + }, + "dev_pip_313_charset_normalizer_cp313_cp313_musllinux_1_2_ppc64le_4b67fdab": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "charset-normalizer==3.4.0", + "sha256": "4b67fdab07fdd3c10bb21edab3cbfe8cf5696f453afce75d815d9d7223fbe88b", + "urls": [ + "https://files.pythonhosted.org/packages/ac/a0/c1b5298de4670d997101fef95b97ac440e8c8d8b4efa5a4d1ef44af82f0d/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl" + ] + } + }, + "dev_pip_313_charset_normalizer_cp313_cp313_musllinux_1_2_s390x_aa41e526": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_s390x.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "charset-normalizer==3.4.0", + "sha256": "aa41e526a5d4a9dfcfbab0716c7e8a1b215abd3f3df5a45cf18a12721d31cb5d", + "urls": [ + "https://files.pythonhosted.org/packages/04/4f/b3961ba0c664989ba63e30595a3ed0875d6790ff26671e2aae2fdc28a399/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_s390x.whl" + ] + } + }, + "dev_pip_313_charset_normalizer_cp313_cp313_musllinux_1_2_x86_64_ffc51962": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "charset-normalizer==3.4.0", + "sha256": "ffc519621dce0c767e96b9c53f09c5d215578e10b02c285809f76509a3931482", + "urls": [ + "https://files.pythonhosted.org/packages/d8/90/6af4cd042066a4adad58ae25648a12c09c879efa4849c705719ba1b23d8c/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_x86_64.whl" + ] + } + }, + "dev_pip_313_charset_normalizer_cp313_cp313_win_amd64_707b82d1": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp313-cp313-win_amd64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "charset-normalizer==3.4.0", + "sha256": "707b82d19e65c9bd28b81dde95249b07bf9f5b90ebe1ef17d9b57473f8a64b7b", + "urls": [ + "https://files.pythonhosted.org/packages/65/97/fc9bbc54ee13d33dc54a7fcf17b26368b18505500fc01e228c27b5222d80/charset_normalizer-3.4.0-cp313-cp313-win_amd64.whl" + ] + } + }, + "dev_pip_313_charset_normalizer_py3_none_any_fe9f97fe": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "charset-normalizer==3.4.0", + "sha256": "fe9f97feb71aa9896b81973a7bbada8c49501dc73e58a10fcef6663af95e5079", + "urls": [ + "https://files.pythonhosted.org/packages/bf/9b/08c0432272d77b04803958a4598a51e2a4b51c06640af8b8f0f908c18bf2/charset_normalizer-3.4.0-py3-none-any.whl" + ] + } + }, + "dev_pip_313_colorama_py2_none_any_4f1d9991": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_windows_x86_64" + ], + "filename": "colorama-0.4.6-py2.py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "colorama==0.4.6", + "sha256": "4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", + "urls": [ + "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl" + ] + } + }, + "dev_pip_313_docutils_py3_none_any_dafca5b9": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "docutils-0.21.2-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "docutils==0.21.2", + "sha256": "dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2", + "urls": [ + "https://files.pythonhosted.org/packages/8f/d7/9322c609343d929e75e7e5e6255e614fcc67572cfd083959cdef3b7aad79/docutils-0.21.2-py3-none-any.whl" + ] + } + }, + "dev_pip_313_idna_py3_none_any_946d195a": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "idna-3.10-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "idna==3.10", + "sha256": "946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", + "urls": [ + "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl" + ] + } + }, + "dev_pip_313_imagesize_py2_none_any_0d8d18d0": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "imagesize-1.4.1-py2.py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "imagesize==1.4.1", + "sha256": "0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b", + "urls": [ + "https://files.pythonhosted.org/packages/ff/62/85c4c919272577931d407be5ba5d71c20f0b616d31a0befe0ae45bb79abd/imagesize-1.4.1-py2.py3-none-any.whl" + ] + } + }, + "dev_pip_313_jinja2_py3_none_any_bc5dd2ab": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "jinja2-3.1.4-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "jinja2==3.1.4", + "sha256": "bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d", + "urls": [ + "https://files.pythonhosted.org/packages/31/80/3a54838c3fb461f6fec263ebf3a3a41771bd05190238de3486aae8540c36/jinja2-3.1.4-py3-none-any.whl" + ] + } + }, + "dev_pip_313_markdown_it_py_py3_none_any_35521684": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "markdown_it_py-3.0.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "markdown-it-py==3.0.0", + "sha256": "355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", + "urls": [ + "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl" + ] + } + }, + "dev_pip_313_markupsafe_cp313_cp313_macosx_10_13_universal2_ba9527cd": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "markupsafe==3.0.2", + "sha256": "ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd", + "urls": [ + "https://files.pythonhosted.org/packages/83/0e/67eb10a7ecc77a0c2bbe2b0235765b98d164d81600746914bebada795e97/MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl" + ] + } + }, + "dev_pip_313_markupsafe_cp313_cp313_macosx_11_0_arm64_f8b3d067": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "markupsafe==3.0.2", + "sha256": "f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430", + "urls": [ + "https://files.pythonhosted.org/packages/2b/6d/9409f3684d3335375d04e5f05744dfe7e9f120062c9857df4ab490a1031a/MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl" + ] + } + }, + "dev_pip_313_markupsafe_cp313_cp313_manylinux_2_17_aarch64_569511d3": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "markupsafe==3.0.2", + "sha256": "569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094", + "urls": [ + "https://files.pythonhosted.org/packages/d2/f5/6eadfcd3885ea85fe2a7c128315cc1bb7241e1987443d78c8fe712d03091/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" + ] + } + }, + "dev_pip_313_markupsafe_cp313_cp313_manylinux_2_17_x86_64_15ab75ef": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "markupsafe==3.0.2", + "sha256": "15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396", + "urls": [ + "https://files.pythonhosted.org/packages/0c/91/96cf928db8236f1bfab6ce15ad070dfdd02ed88261c2afafd4b43575e9e9/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" + ] + } + }, + "dev_pip_313_markupsafe_cp313_cp313_musllinux_1_2_aarch64_cdb82a87": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "markupsafe==3.0.2", + "sha256": "cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a", + "urls": [ + "https://files.pythonhosted.org/packages/2a/9f/8619835cd6a711d6272d62abb78c033bda638fdc54c4e7f4272cf1c0962b/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl" + ] + } + }, + "dev_pip_313_markupsafe_cp313_cp313_musllinux_1_2_x86_64_444dcda7": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "markupsafe==3.0.2", + "sha256": "444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c", + "urls": [ + "https://files.pythonhosted.org/packages/ce/4f/9a02c1d335caabe5c4efb90e1b6e8ee944aa245c1aaaab8e8a618987d816/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl" + ] + } + }, + "dev_pip_313_markupsafe_cp313_cp313_win_amd64_e6a2a455": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "markupsafe==3.0.2", + "sha256": "e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f", + "urls": [ + "https://files.pythonhosted.org/packages/29/88/07df22d2dd4df40aba9f3e402e6dc1b8ee86297dddbad4872bd5e7b0094f/MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl" + ] + } + }, + "dev_pip_313_markupsafe_cp313_cp313t_macosx_10_13_universal2_b5a6b3ad": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "markupsafe==3.0.2", + "sha256": "b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c", + "urls": [ + "https://files.pythonhosted.org/packages/62/6a/8b89d24db2d32d433dffcd6a8779159da109842434f1dd2f6e71f32f738c/MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl" + ] + } + }, + "dev_pip_313_markupsafe_cp313_cp313t_macosx_11_0_arm64_a904af0a": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "markupsafe==3.0.2", + "sha256": "a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb", + "urls": [ + "https://files.pythonhosted.org/packages/7a/06/a10f955f70a2e5a9bf78d11a161029d278eeacbd35ef806c3fd17b13060d/MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl" + ] + } + }, + "dev_pip_313_markupsafe_cp313_cp313t_manylinux_2_17_aarch64_4aa4e5fa": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "markupsafe==3.0.2", + "sha256": "4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c", + "urls": [ + "https://files.pythonhosted.org/packages/34/cf/65d4a571869a1a9078198ca28f39fba5fbb910f952f9dbc5220afff9f5e6/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" + ] + } + }, + "dev_pip_313_markupsafe_cp313_cp313t_manylinux_2_17_x86_64_c0ef13ea": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "markupsafe==3.0.2", + "sha256": "c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d", + "urls": [ + "https://files.pythonhosted.org/packages/0c/e3/90e9651924c430b885468b56b3d597cabf6d72be4b24a0acd1fa0e12af67/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" + ] + } + }, + "dev_pip_313_markupsafe_cp313_cp313t_musllinux_1_2_aarch64_6381026f": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "markupsafe==3.0.2", + "sha256": "6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5", + "urls": [ + "https://files.pythonhosted.org/packages/bb/35/cbe9238ec3f47ac9a7c8b3df7a808e7cb50fe149dc7039f5f454b3fba218/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl" + ] + } + }, + "dev_pip_313_markupsafe_cp313_cp313t_musllinux_1_2_x86_64_131a3c76": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "markupsafe==3.0.2", + "sha256": "131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9", + "urls": [ + "https://files.pythonhosted.org/packages/0d/80/0985960e4b89922cb5a0bac0ed39c5b96cbc1a536a99f30e8c220a996ed9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl" + ] + } + }, + "dev_pip_313_markupsafe_cp313_cp313t_win_amd64_e444a31f": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "markupsafe==3.0.2", + "sha256": "e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", + "urls": [ + "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl" + ] + } + }, + "dev_pip_313_mdit_py_plugins_py3_none_any_0c673c3f": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "mdit_py_plugins-0.4.2-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "mdit-py-plugins==0.4.2", + "sha256": "0c673c3f889399a33b95e88d2f0d111b4447bdfea7f237dab2d488f459835636", + "urls": [ + "https://files.pythonhosted.org/packages/a7/f7/7782a043553ee469c1ff49cfa1cdace2d6bf99a1f333cf38676b3ddf30da/mdit_py_plugins-0.4.2-py3-none-any.whl" + ] + } + }, + "dev_pip_313_mdurl_py3_none_any_84008a41": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "mdurl-0.1.2-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "mdurl==0.1.2", + "sha256": "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", + "urls": [ + "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl" + ] + } + }, + "dev_pip_313_myst_parser_py3_none_any_b9317997": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "myst_parser-4.0.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "myst-parser==4.0.0", + "sha256": "b9317997552424448c6096c2558872fdb6f81d3ecb3a40ce84a7518798f3f28d", + "urls": [ + "https://files.pythonhosted.org/packages/ca/b4/b036f8fdb667587bb37df29dc6644681dd78b7a2a6321a34684b79412b28/myst_parser-4.0.0-py3-none-any.whl" + ] + } + }, + "dev_pip_313_packaging_py3_none_any_5b8f2217": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "packaging-24.1-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "packaging==24.1", + "sha256": "5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124", + "urls": [ + "https://files.pythonhosted.org/packages/08/aa/cc0199a5f0ad350994d660967a8efb233fe0416e4639146c089643407ce6/packaging-24.1-py3-none-any.whl" + ] + } + }, + "dev_pip_313_pygments_py3_none_any_b8e6aca0": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "pygments-2.18.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "pygments==2.18.0", + "sha256": "b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a", + "urls": [ + "https://files.pythonhosted.org/packages/f7/3f/01c8b82017c199075f8f788d0d906b9ffbbc5a47dc9918a945e13d5a2bda/pygments-2.18.0-py3-none-any.whl" + ] + } + }, + "dev_pip_313_pyyaml_cp313_cp313_macosx_10_13_x86_64_efdca563": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "pyyaml==6.0.2", + "sha256": "efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", + "urls": [ + "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl" + ] + } + }, + "dev_pip_313_pyyaml_cp313_cp313_macosx_11_0_arm64_50187695": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "pyyaml==6.0.2", + "sha256": "50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", + "urls": [ + "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl" + ] + } + }, + "dev_pip_313_pyyaml_cp313_cp313_manylinux_2_17_aarch64_0ffe8360": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "pyyaml==6.0.2", + "sha256": "0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", + "urls": [ + "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" + ] + } + }, + "dev_pip_313_pyyaml_cp313_cp313_manylinux_2_17_s390x_17e311b6": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "pyyaml==6.0.2", + "sha256": "17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", + "urls": [ + "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl" + ] + } + }, + "dev_pip_313_pyyaml_cp313_cp313_manylinux_2_17_x86_64_70b18959": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "pyyaml==6.0.2", + "sha256": "70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", + "urls": [ + "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" + ] + } + }, + "dev_pip_313_pyyaml_cp313_cp313_musllinux_1_1_aarch64_41e4e395": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "pyyaml==6.0.2", + "sha256": "41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", + "urls": [ + "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl" + ] + } + }, + "dev_pip_313_pyyaml_cp313_cp313_musllinux_1_1_x86_64_68ccc602": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "pyyaml==6.0.2", + "sha256": "68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", + "urls": [ + "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl" + ] + } + }, + "dev_pip_313_pyyaml_cp313_cp313_win_amd64_8388ee19": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "PyYAML-6.0.2-cp313-cp313-win_amd64.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "pyyaml==6.0.2", + "sha256": "8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", + "urls": [ + "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl" + ] + } + }, + "dev_pip_313_readthedocs_sphinx_ext_py2_none_any_f8c56184": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "readthedocs_sphinx_ext-2.2.5-py2.py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "readthedocs-sphinx-ext==2.2.5", + "sha256": "f8c56184ea011c972dd45a90122568587cc85b0127bc9cf064d17c68bc809daa", + "urls": [ + "https://files.pythonhosted.org/packages/64/71/c89e7709a0d4f93af1848e9855112299a820b470d84f917b4dd5998bdd07/readthedocs_sphinx_ext-2.2.5-py2.py3-none-any.whl" + ] + } + }, + "dev_pip_313_requests_py3_none_any_70761cfe": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "requests-2.32.3-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "requests==2.32.3", + "sha256": "70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", + "urls": [ + "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl" + ] + } + }, + "dev_pip_313_snowballstemmer_py2_none_any_c8e1716e": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "snowballstemmer-2.2.0-py2.py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "snowballstemmer==2.2.0", + "sha256": "c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a", + "urls": [ + "https://files.pythonhosted.org/packages/ed/dc/c02e01294f7265e63a7315fe086dd1df7dacb9f840a804da846b96d01b96/snowballstemmer-2.2.0-py2.py3-none-any.whl" + ] + } + }, + "dev_pip_313_sphinx_autodoc2_py3_none_any_e867013b": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "sphinx_autodoc2-0.5.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "sphinx-autodoc2==0.5.0", + "sha256": "e867013b1512f9d6d7e6f6799f8b537d6884462acd118ef361f3f619a60b5c9e", + "urls": [ + "https://files.pythonhosted.org/packages/19/e6/48d47961bbdae755ba9c17dfc65d89356312c67668dcb36c87cfadfa1964/sphinx_autodoc2-0.5.0-py3-none-any.whl" + ] + } + }, + "dev_pip_313_sphinx_py3_none_any_09719015": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "sphinx-8.1.3-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "sphinx==8.1.3", + "sha256": "09719015511837b76bf6e03e42eb7595ac8c2e41eeb9c29c5b755c6b677992a2", + "urls": [ + "https://files.pythonhosted.org/packages/26/60/1ddff83a56d33aaf6f10ec8ce84b4c007d9368b21008876fceda7e7381ef/sphinx-8.1.3-py3-none-any.whl" + ] + } + }, + "dev_pip_313_sphinx_reredirects_py3_none_any_444ae143": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "sphinx_reredirects-0.1.5-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "sphinx-reredirects==0.1.5", + "sha256": "444ae1438fba4418242ca76d6a6de3eaee82aaf0d8f2b0cac71a15d32ce6eba2", + "urls": [ + "https://files.pythonhosted.org/packages/34/97/1f8143f87330f4c9ccc2c08ae9cd3cb1ce2944c51e98dd7ff141154fbcc7/sphinx_reredirects-0.1.5-py3-none-any.whl" + ] + } + }, + "dev_pip_313_sphinx_rtd_theme_py2_none_any_921c0ece": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "sphinx_rtd_theme-3.0.1-py2.py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "sphinx-rtd-theme==3.0.1", + "sha256": "921c0ece75e90633ee876bd7b148cfaad136b481907ad154ac3669b6fc957916", + "urls": [ + "https://files.pythonhosted.org/packages/c8/51/aed903ad0843a06ccfb93e6e8849e752a9379eaec0f50d9237ae373dd737/sphinx_rtd_theme-3.0.1-py2.py3-none-any.whl" + ] + } + }, + "dev_pip_313_sphinxcontrib_applehelp_py3_none_any_4cd3f0ec": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "sphinxcontrib-applehelp==2.0.0", + "sha256": "4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", + "urls": [ + "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl" + ] + } + }, + "dev_pip_313_sphinxcontrib_devhelp_py3_none_any_aefb8b83": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "sphinxcontrib-devhelp==2.0.0", + "sha256": "aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", + "urls": [ + "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl" + ] + } + }, + "dev_pip_313_sphinxcontrib_htmlhelp_py3_none_any_16675982": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "sphinxcontrib-htmlhelp==2.1.0", + "sha256": "166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", + "urls": [ + "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl" + ] + } + }, + "dev_pip_313_sphinxcontrib_jquery_py2_none_any_f936030d": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "sphinxcontrib_jquery-4.1-py2.py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "sphinxcontrib-jquery==4.1", + "sha256": "f936030d7d0147dd026a4f2b5a57343d233f1fc7b363f68b3d4f1cb0993878ae", + "urls": [ + "https://files.pythonhosted.org/packages/76/85/749bd22d1a68db7291c89e2ebca53f4306c3f205853cf31e9de279034c3c/sphinxcontrib_jquery-4.1-py2.py3-none-any.whl" + ] + } + }, + "dev_pip_313_sphinxcontrib_jsmath_py2_none_any_2ec2eaeb": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "sphinxcontrib-jsmath==1.0.1", + "sha256": "2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", + "urls": [ + "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl" + ] + } + }, + "dev_pip_313_sphinxcontrib_qthelp_py3_none_any_b18a828c": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "sphinxcontrib-qthelp==2.0.0", + "sha256": "b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", + "urls": [ + "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl" + ] + } + }, + "dev_pip_313_sphinxcontrib_serializinghtml_py3_none_any_6e2cb0ee": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "sphinxcontrib-serializinghtml==2.0.0", + "sha256": "6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", + "urls": [ + "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl" + ] + } + }, + "dev_pip_313_typing_extensions_py3_none_any_04e5ca03": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "typing_extensions-4.12.2-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "typing-extensions==4.12.2", + "sha256": "04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", + "urls": [ + "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl" + ] + } + }, + "dev_pip_313_urllib3_py3_none_any_ca899ca0": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@dev_pip//{name}:{target}", + "experimental_target_platforms": [ + "cp313_linux_aarch64", + "cp313_linux_arm", + "cp313_linux_ppc", + "cp313_linux_s390x", + "cp313_linux_x86_64", + "cp313_osx_aarch64", + "cp313_osx_x86_64", + "cp313_windows_x86_64" + ], + "filename": "urllib3-2.2.3-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_13_0_host//:python", + "repo": "dev_pip_313", + "requirement": "urllib3==2.2.3", + "sha256": "ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac", + "urls": [ + "https://files.pythonhosted.org/packages/ce/d9/5f4c13cecde62396b0d3fe530a50ccea91e7dfc1ccf0e09c228841bb5ba8/urllib3-2.2.3-py3-none-any.whl" + ] + } + }, + "pip_deps_310_numpy": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@pip_deps//{name}:{target}", + "python_interpreter_target": "@@+python+python_3_10_host//:python", + "repo": "pip_deps_310", + "requirement": "numpy<=1.26.1" + } + }, + "pip_deps_310_setuptools": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@pip_deps//{name}:{target}", + "python_interpreter_target": "@@+python+python_3_10_host//:python", + "repo": "pip_deps_310", + "requirement": "setuptools<=70.3.0" + } + }, + "pip_deps_311_numpy": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@pip_deps//{name}:{target}", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "pip_deps_311", + "requirement": "numpy<=1.26.1" + } + }, + "pip_deps_311_setuptools": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@pip_deps//{name}:{target}", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "pip_deps_311", + "requirement": "setuptools<=70.3.0" + } + }, + "pip_deps_312_numpy": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@pip_deps//{name}:{target}", + "python_interpreter_target": "@@+python+python_3_12_host//:python", + "repo": "pip_deps_312", + "requirement": "numpy<=1.26.1" + } + }, + "pip_deps_312_setuptools": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@pip_deps//{name}:{target}", + "python_interpreter_target": "@@+python+python_3_12_host//:python", + "repo": "pip_deps_312", + "requirement": "setuptools<=70.3.0" + } + }, + "pip_deps_38_numpy": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@pip_deps//{name}:{target}", + "python_interpreter_target": "@@+python+python_3_8_host//:python", + "repo": "pip_deps_38", + "requirement": "numpy<=1.26.1" + } + }, + "pip_deps_38_setuptools": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@pip_deps//{name}:{target}", + "python_interpreter_target": "@@+python+python_3_8_host//:python", + "repo": "pip_deps_38", + "requirement": "setuptools<=70.3.0" + } + }, + "pip_deps_39_numpy": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@pip_deps//{name}:{target}", + "python_interpreter_target": "@@+python+python_3_9_host//:python", + "repo": "pip_deps_39", + "requirement": "numpy<=1.26.1" + } + }, + "pip_deps_39_setuptools": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@pip_deps//{name}:{target}", + "python_interpreter_target": "@@+python+python_3_9_host//:python", + "repo": "pip_deps_39", + "requirement": "setuptools<=70.3.0" + } + }, + "pypiserver_311_pip_py3_none_any_ba0d021a": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@pypiserver//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "pip-24.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "pypiserver_311", + "requirement": "pip==24.0", + "sha256": "ba0d021a166865d2265246961bec0152ff124de910c5cc39f1156ce3fa7c69dc", + "urls": [ + "https://files.pythonhosted.org/packages/8a/6a/19e9fe04fca059ccf770861c7d5721ab4c2aebc539889e97c7977528a53b/pip-24.0-py3-none-any.whl" + ] + } + }, + "pypiserver_311_pypiserver_py2_none_any_1dd98fb9": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@pypiserver//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "pypiserver-2.0.1-py2.py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "pypiserver_311", + "requirement": "pypiserver==2.0.1", + "sha256": "1dd98fb99d2da4199fb44c7284e57d69a9f7fda2c6c8dc01975c151c592677bf", + "urls": [ + "https://files.pythonhosted.org/packages/34/95/6c70e2f7e8375354fd7b1db08405c93674f2e4ce4e714f379fadd06a92b1/pypiserver-2.0.1-py2.py3-none-any.whl" + ] + } + }, + "rules_fuzzing_py_deps_310_absl_py": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", + "extra_pip_args": [ + "--require-hashes" + ], + "python_interpreter_target": "@@+python+python_3_10_host//:python", + "repo": "rules_fuzzing_py_deps_310", + "requirement": "absl-py==2.0.0 --hash=sha256:9a28abb62774ae4e8edbe2dd4c49ffcd45a6a848952a5eccc6a49f3f0fc1e2f3" + } + }, + "rules_fuzzing_py_deps_310_six": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", + "extra_pip_args": [ + "--require-hashes" + ], + "python_interpreter_target": "@@+python+python_3_10_host//:python", + "repo": "rules_fuzzing_py_deps_310", + "requirement": "six==1.16.0 --hash=sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254" + } + }, + "rules_fuzzing_py_deps_311_absl_py": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", + "extra_pip_args": [ + "--require-hashes" + ], + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_fuzzing_py_deps_311", + "requirement": "absl-py==2.0.0 --hash=sha256:9a28abb62774ae4e8edbe2dd4c49ffcd45a6a848952a5eccc6a49f3f0fc1e2f3" + } + }, + "rules_fuzzing_py_deps_311_six": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", + "extra_pip_args": [ + "--require-hashes" + ], + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_fuzzing_py_deps_311", + "requirement": "six==1.16.0 --hash=sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254" + } + }, + "rules_fuzzing_py_deps_312_absl_py": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", + "extra_pip_args": [ + "--require-hashes" + ], + "python_interpreter_target": "@@+python+python_3_12_host//:python", + "repo": "rules_fuzzing_py_deps_312", + "requirement": "absl-py==2.0.0 --hash=sha256:9a28abb62774ae4e8edbe2dd4c49ffcd45a6a848952a5eccc6a49f3f0fc1e2f3" + } + }, + "rules_fuzzing_py_deps_312_six": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", + "extra_pip_args": [ + "--require-hashes" + ], + "python_interpreter_target": "@@+python+python_3_12_host//:python", + "repo": "rules_fuzzing_py_deps_312", + "requirement": "six==1.16.0 --hash=sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254" + } + }, + "rules_fuzzing_py_deps_38_absl_py": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", + "extra_pip_args": [ + "--require-hashes" + ], + "python_interpreter_target": "@@+python+python_3_8_host//:python", + "repo": "rules_fuzzing_py_deps_38", + "requirement": "absl-py==2.0.0 --hash=sha256:9a28abb62774ae4e8edbe2dd4c49ffcd45a6a848952a5eccc6a49f3f0fc1e2f3" + } + }, + "rules_fuzzing_py_deps_38_six": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", + "extra_pip_args": [ + "--require-hashes" + ], + "python_interpreter_target": "@@+python+python_3_8_host//:python", + "repo": "rules_fuzzing_py_deps_38", + "requirement": "six==1.16.0 --hash=sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254" + } + }, + "rules_fuzzing_py_deps_39_absl_py": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", + "extra_pip_args": [ + "--require-hashes" + ], + "python_interpreter_target": "@@+python+python_3_9_host//:python", + "repo": "rules_fuzzing_py_deps_39", + "requirement": "absl-py==2.0.0 --hash=sha256:9a28abb62774ae4e8edbe2dd4c49ffcd45a6a848952a5eccc6a49f3f0fc1e2f3" + } + }, + "rules_fuzzing_py_deps_39_six": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", + "extra_pip_args": [ + "--require-hashes" + ], + "python_interpreter_target": "@@+python+python_3_9_host//:python", + "repo": "rules_fuzzing_py_deps_39", + "requirement": "six==1.16.0 --hash=sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254" + } + }, + "rules_python_publish_deps_311_backports_tarfile_py3_none_any_77e284d7": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "backports.tarfile-1.2.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "backports-tarfile==1.2.0", + "sha256": "77e284d754527b01fb1e6fa8a1afe577858ebe4e9dad8919e34c862cb399bc34", + "urls": [ + "https://files.pythonhosted.org/packages/b9/fa/123043af240e49752f1c4bd24da5053b6bd00cad78c2be53c0d1e8b975bc/backports.tarfile-1.2.0-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_backports_tarfile_sdist_d75e02c2": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "backports_tarfile-1.2.0.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "backports-tarfile==1.2.0", + "sha256": "d75e02c268746e1b8144c278978b6e98e85de6ad16f8e4b0844a154557eca991", + "urls": [ + "https://files.pythonhosted.org/packages/86/72/cd9b395f25e290e633655a100af28cb253e4393396264a98bd5f5951d50f/backports_tarfile-1.2.0.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_certifi_py3_none_any_922820b5": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "certifi-2024.8.30-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "certifi==2024.8.30", + "sha256": "922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8", + "urls": [ + "https://files.pythonhosted.org/packages/12/90/3c9ff0512038035f59d279fddeb79f5f1eccd8859f06d6163c58798b9487/certifi-2024.8.30-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_certifi_sdist_bec941d2": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "certifi-2024.8.30.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "certifi==2024.8.30", + "sha256": "bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9", + "urls": [ + "https://files.pythonhosted.org/packages/b0/ee/9b19140fe824b367c04c5e1b369942dd754c4c5462d5674002f75c4dedc1/certifi-2024.8.30.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_cffi_cp311_cp311_manylinux_2_17_aarch64_a1ed2dd2": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "filename": "cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "cffi==1.17.1", + "sha256": "a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41", + "urls": [ + "https://files.pythonhosted.org/packages/2e/ea/70ce63780f096e16ce8588efe039d3c4f91deb1dc01e9c73a287939c79a6/cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" + ] + } + }, + "rules_python_publish_deps_311_cffi_cp311_cp311_manylinux_2_17_ppc64le_46bf4316": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "filename": "cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "cffi==1.17.1", + "sha256": "46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1", + "urls": [ + "https://files.pythonhosted.org/packages/1c/a0/a4fa9f4f781bda074c3ddd57a572b060fa0df7655d2a4247bbe277200146/cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl" + ] + } + }, + "rules_python_publish_deps_311_cffi_cp311_cp311_manylinux_2_17_s390x_a24ed04c": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "filename": "cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "cffi==1.17.1", + "sha256": "a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6", + "urls": [ + "https://files.pythonhosted.org/packages/62/12/ce8710b5b8affbcdd5c6e367217c242524ad17a02fe5beec3ee339f69f85/cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl" + ] + } + }, + "rules_python_publish_deps_311_cffi_cp311_cp311_manylinux_2_17_x86_64_610faea7": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "filename": "cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "cffi==1.17.1", + "sha256": "610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d", + "urls": [ + "https://files.pythonhosted.org/packages/ff/6b/d45873c5e0242196f042d555526f92aa9e0c32355a1be1ff8c27f077fd37/cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" + ] + } + }, + "rules_python_publish_deps_311_cffi_cp311_cp311_musllinux_1_1_aarch64_a9b15d49": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "filename": "cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "cffi==1.17.1", + "sha256": "a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6", + "urls": [ + "https://files.pythonhosted.org/packages/1a/52/d9a0e523a572fbccf2955f5abe883cfa8bcc570d7faeee06336fbd50c9fc/cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl" + ] + } + }, + "rules_python_publish_deps_311_cffi_cp311_cp311_musllinux_1_1_x86_64_fc48c783": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "filename": "cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "cffi==1.17.1", + "sha256": "fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b", + "urls": [ + "https://files.pythonhosted.org/packages/f8/4a/34599cac7dfcd888ff54e801afe06a19c17787dfd94495ab0c8d35fe99fb/cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl" + ] + } + }, + "rules_python_publish_deps_311_cffi_sdist_1c39c601": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "cffi-1.17.1.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "cffi==1.17.1", + "sha256": "1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", + "urls": [ + "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_macosx_10_9_universal2_0d99dd8f": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "0d99dd8ff461990f12d6e42c7347fd9ab2532fb70e9621ba520f9e8637161d7c", + "urls": [ + "https://files.pythonhosted.org/packages/9c/61/73589dcc7a719582bf56aae309b6103d2762b526bffe189d635a7fcfd998/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl" + ] + } + }, + "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_macosx_10_9_x86_64_c57516e5": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "c57516e58fd17d03ebe67e181a4e4e2ccab1168f8c2976c6a334d4f819fe5944", + "urls": [ + "https://files.pythonhosted.org/packages/77/d5/8c982d58144de49f59571f940e329ad6e8615e1e82ef84584c5eeb5e1d72/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl" + ] + } + }, + "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_macosx_11_0_arm64_6dba5d19": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "6dba5d19c4dfab08e58d5b36304b3f92f3bd5d42c1a3fa37b5ba5cdf6dfcbcee", + "urls": [ + "https://files.pythonhosted.org/packages/bf/19/411a64f01ee971bed3231111b69eb56f9331a769072de479eae7de52296d/charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl" + ] + } + }, + "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_manylinux_2_17_aarch64_bf4475b8": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "bf4475b82be41b07cc5e5ff94810e6a01f276e37c2d55571e3fe175e467a1a1c", + "urls": [ + "https://files.pythonhosted.org/packages/4c/92/97509850f0d00e9f14a46bc751daabd0ad7765cff29cdfb66c68b6dad57f/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" + ] + } + }, + "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_manylinux_2_17_ppc64le_ce031db0": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "ce031db0408e487fd2775d745ce30a7cd2923667cf3b69d48d219f1d8f5ddeb6", + "urls": [ + "https://files.pythonhosted.org/packages/e2/29/d227805bff72ed6d6cb1ce08eec707f7cfbd9868044893617eb331f16295/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl" + ] + } + }, + "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_manylinux_2_17_s390x_8ff4e7cd": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "8ff4e7cdfdb1ab5698e675ca622e72d58a6fa2a8aa58195de0c0061288e6e3ea", + "urls": [ + "https://files.pythonhosted.org/packages/13/bc/87c2c9f2c144bedfa62f894c3007cd4530ba4b5351acb10dc786428a50f0/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl" + ] + } + }, + "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_manylinux_2_17_x86_64_3710a975": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "3710a9751938947e6327ea9f3ea6332a09bf0ba0c09cae9cb1f250bd1f1549bc", + "urls": [ + "https://files.pythonhosted.org/packages/eb/5b/6f10bad0f6461fa272bfbbdf5d0023b5fb9bc6217c92bf068fa5a99820f5/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" + ] + } + }, + "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_musllinux_1_2_aarch64_47334db7": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "47334db71978b23ebcf3c0f9f5ee98b8d65992b65c9c4f2d34c2eaf5bcaf0594", + "urls": [ + "https://files.pythonhosted.org/packages/d7/a1/493919799446464ed0299c8eef3c3fad0daf1c3cd48bff9263c731b0d9e2/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl" + ] + } + }, + "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_musllinux_1_2_ppc64le_f1a2f519": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "f1a2f519ae173b5b6a2c9d5fa3116ce16e48b3462c8b96dfdded11055e3d6365", + "urls": [ + "https://files.pythonhosted.org/packages/75/d2/0ab54463d3410709c09266dfb416d032a08f97fd7d60e94b8c6ef54ae14b/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl" + ] + } + }, + "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_musllinux_1_2_s390x_63bc5c4a": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "63bc5c4ae26e4bc6be6469943b8253c0fd4e4186c43ad46e713ea61a0ba49129", + "urls": [ + "https://files.pythonhosted.org/packages/8d/c9/27e41d481557be53d51e60750b85aa40eaf52b841946b3cdeff363105737/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl" + ] + } + }, + "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_musllinux_1_2_x86_64_bcb4f8ea": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "bcb4f8ea87d03bc51ad04add8ceaf9b0f085ac045ab4d74e73bbc2dc033f0236", + "urls": [ + "https://files.pythonhosted.org/packages/ee/44/4f62042ca8cdc0cabf87c0fc00ae27cd8b53ab68be3605ba6d071f742ad3/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl" + ] + } + }, + "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_win_amd64_cee4373f": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "cee4373f4d3ad28f1ab6290684d8e2ebdb9e7a1b74fdc39e4c211995f77bec27", + "urls": [ + "https://files.pythonhosted.org/packages/0b/6e/b13bd47fa9023b3699e94abf565b5a2f0b0be6e9ddac9812182596ee62e4/charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl" + ] + } + }, + "rules_python_publish_deps_311_charset_normalizer_py3_none_any_fe9f97fe": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "charset_normalizer-3.4.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "fe9f97feb71aa9896b81973a7bbada8c49501dc73e58a10fcef6663af95e5079", + "urls": [ + "https://files.pythonhosted.org/packages/bf/9b/08c0432272d77b04803958a4598a51e2a4b51c06640af8b8f0f908c18bf2/charset_normalizer-3.4.0-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_charset_normalizer_sdist_223217c3": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "charset_normalizer-3.4.0.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "charset-normalizer==3.4.0", + "sha256": "223217c3d4f82c3ac5e29032b3f1c2eb0fb591b72161f86d93f5719079dae93e", + "urls": [ + "https://files.pythonhosted.org/packages/f2/4f/e1808dc01273379acc506d18f1504eb2d299bd4131743b9fc54d7be4df1e/charset_normalizer-3.4.0.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_cryptography_cp39_abi3_manylinux_2_17_aarch64_846da004": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "filename": "cryptography-43.0.3-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "cryptography==43.0.3", + "sha256": "846da004a5804145a5f441b8530b4bf35afbf7da70f82409f151695b127213d5", + "urls": [ + "https://files.pythonhosted.org/packages/2f/78/55356eb9075d0be6e81b59f45c7b48df87f76a20e73893872170471f3ee8/cryptography-43.0.3-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" + ] + } + }, + "rules_python_publish_deps_311_cryptography_cp39_abi3_manylinux_2_17_x86_64_0f996e72": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "filename": "cryptography-43.0.3-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "cryptography==43.0.3", + "sha256": "0f996e7268af62598f2fc1204afa98a3b5712313a55c4c9d434aef49cadc91d4", + "urls": [ + "https://files.pythonhosted.org/packages/2a/2c/488776a3dc843f95f86d2f957ca0fc3407d0242b50bede7fad1e339be03f/cryptography-43.0.3-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" + ] + } + }, + "rules_python_publish_deps_311_cryptography_cp39_abi3_manylinux_2_28_aarch64_f7b178f1": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "filename": "cryptography-43.0.3-cp39-abi3-manylinux_2_28_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "cryptography==43.0.3", + "sha256": "f7b178f11ed3664fd0e995a47ed2b5ff0a12d893e41dd0494f406d1cf555cab7", + "urls": [ + "https://files.pythonhosted.org/packages/7c/04/2345ca92f7a22f601a9c62961741ef7dd0127c39f7310dffa0041c80f16f/cryptography-43.0.3-cp39-abi3-manylinux_2_28_aarch64.whl" + ] + } + }, + "rules_python_publish_deps_311_cryptography_cp39_abi3_manylinux_2_28_x86_64_c2e6fc39": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "filename": "cryptography-43.0.3-cp39-abi3-manylinux_2_28_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "cryptography==43.0.3", + "sha256": "c2e6fc39c4ab499049df3bdf567f768a723a5e8464816e8f009f121a5a9f4405", + "urls": [ + "https://files.pythonhosted.org/packages/ac/25/e715fa0bc24ac2114ed69da33adf451a38abb6f3f24ec207908112e9ba53/cryptography-43.0.3-cp39-abi3-manylinux_2_28_x86_64.whl" + ] + } + }, + "rules_python_publish_deps_311_cryptography_cp39_abi3_musllinux_1_2_aarch64_e1be4655": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "filename": "cryptography-43.0.3-cp39-abi3-musllinux_1_2_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "cryptography==43.0.3", + "sha256": "e1be4655c7ef6e1bbe6b5d0403526601323420bcf414598955968c9ef3eb7d16", + "urls": [ + "https://files.pythonhosted.org/packages/21/ce/b9c9ff56c7164d8e2edfb6c9305045fbc0df4508ccfdb13ee66eb8c95b0e/cryptography-43.0.3-cp39-abi3-musllinux_1_2_aarch64.whl" + ] + } + }, + "rules_python_publish_deps_311_cryptography_cp39_abi3_musllinux_1_2_x86_64_df6b6c6d": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "filename": "cryptography-43.0.3-cp39-abi3-musllinux_1_2_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "cryptography==43.0.3", + "sha256": "df6b6c6d742395dd77a23ea3728ab62f98379eff8fb61be2744d4679ab678f73", + "urls": [ + "https://files.pythonhosted.org/packages/2a/33/b3682992ab2e9476b9c81fff22f02c8b0a1e6e1d49ee1750a67d85fd7ed2/cryptography-43.0.3-cp39-abi3-musllinux_1_2_x86_64.whl" + ] + } + }, + "rules_python_publish_deps_311_cryptography_sdist_315b9001": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "cryptography-43.0.3.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "cryptography==43.0.3", + "sha256": "315b9001266a492a6ff443b61238f956b214dbec9910a081ba5b6646a055a805", + "urls": [ + "https://files.pythonhosted.org/packages/0d/05/07b55d1fa21ac18c3a8c79f764e2514e6f6a9698f1be44994f5adf0d29db/cryptography-43.0.3.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_docutils_py3_none_any_dafca5b9": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "docutils-0.21.2-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "docutils==0.21.2", + "sha256": "dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2", + "urls": [ + "https://files.pythonhosted.org/packages/8f/d7/9322c609343d929e75e7e5e6255e614fcc67572cfd083959cdef3b7aad79/docutils-0.21.2-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_docutils_sdist_3a6b1873": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "docutils-0.21.2.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "docutils==0.21.2", + "sha256": "3a6b18732edf182daa3cd12775bbb338cf5691468f91eeeb109deff6ebfa986f", + "urls": [ + "https://files.pythonhosted.org/packages/ae/ed/aefcc8cd0ba62a0560c3c18c33925362d46c6075480bfa4df87b28e169a9/docutils-0.21.2.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_idna_py3_none_any_946d195a": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "idna-3.10-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "idna==3.10", + "sha256": "946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", + "urls": [ + "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_idna_sdist_12f65c9b": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "idna-3.10.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "idna==3.10", + "sha256": "12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", + "urls": [ + "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_importlib_metadata_py3_none_any_45e54197": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "importlib_metadata-8.5.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "importlib-metadata==8.5.0", + "sha256": "45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b", + "urls": [ + "https://files.pythonhosted.org/packages/a0/d9/a1e041c5e7caa9a05c925f4bdbdfb7f006d1f74996af53467bc394c97be7/importlib_metadata-8.5.0-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_importlib_metadata_sdist_71522656": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "importlib_metadata-8.5.0.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "importlib-metadata==8.5.0", + "sha256": "71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7", + "urls": [ + "https://files.pythonhosted.org/packages/cd/12/33e59336dca5be0c398a7482335911a33aa0e20776128f038019f1a95f1b/importlib_metadata-8.5.0.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_jaraco_classes_py3_none_any_f662826b": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "jaraco.classes-3.4.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "jaraco-classes==3.4.0", + "sha256": "f662826b6bed8cace05e7ff873ce0f9283b5c924470fe664fff1c2f00f581790", + "urls": [ + "https://files.pythonhosted.org/packages/7f/66/b15ce62552d84bbfcec9a4873ab79d993a1dd4edb922cbfccae192bd5b5f/jaraco.classes-3.4.0-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_jaraco_classes_sdist_47a024b5": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "jaraco.classes-3.4.0.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "jaraco-classes==3.4.0", + "sha256": "47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd", + "urls": [ + "https://files.pythonhosted.org/packages/06/c0/ed4a27bc5571b99e3cff68f8a9fa5b56ff7df1c2251cc715a652ddd26402/jaraco.classes-3.4.0.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_jaraco_context_py3_none_any_f797fc48": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "jaraco.context-6.0.1-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "jaraco-context==6.0.1", + "sha256": "f797fc481b490edb305122c9181830a3a5b76d84ef6d1aef2fb9b47ab956f9e4", + "urls": [ + "https://files.pythonhosted.org/packages/ff/db/0c52c4cf5e4bd9f5d7135ec7669a3a767af21b3a308e1ed3674881e52b62/jaraco.context-6.0.1-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_jaraco_context_sdist_9bae4ea5": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "jaraco_context-6.0.1.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "jaraco-context==6.0.1", + "sha256": "9bae4ea555cf0b14938dc0aee7c9f32ed303aa20a3b73e7dc80111628792d1b3", + "urls": [ + "https://files.pythonhosted.org/packages/df/ad/f3777b81bf0b6e7bc7514a1656d3e637b2e8e15fab2ce3235730b3e7a4e6/jaraco_context-6.0.1.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_jaraco_functools_py3_none_any_ad159f13": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "jaraco.functools-4.1.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "jaraco-functools==4.1.0", + "sha256": "ad159f13428bc4acbf5541ad6dec511f91573b90fba04df61dafa2a1231cf649", + "urls": [ + "https://files.pythonhosted.org/packages/9f/4f/24b319316142c44283d7540e76c7b5a6dbd5db623abd86bb7b3491c21018/jaraco.functools-4.1.0-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_jaraco_functools_sdist_70f7e0e2": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "jaraco_functools-4.1.0.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "jaraco-functools==4.1.0", + "sha256": "70f7e0e2ae076498e212562325e805204fc092d7b4c17e0e86c959e249701a9d", + "urls": [ + "https://files.pythonhosted.org/packages/ab/23/9894b3df5d0a6eb44611c36aec777823fc2e07740dabbd0b810e19594013/jaraco_functools-4.1.0.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_jeepney_py3_none_any_c0a454ad": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "filename": "jeepney-0.8.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "jeepney==0.8.0", + "sha256": "c0a454ad016ca575060802ee4d590dd912e35c122fa04e70306de3d076cce755", + "urls": [ + "https://files.pythonhosted.org/packages/ae/72/2a1e2290f1ab1e06f71f3d0f1646c9e4634e70e1d37491535e19266e8dc9/jeepney-0.8.0-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_jeepney_sdist_5efe48d2": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "jeepney-0.8.0.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "jeepney==0.8.0", + "sha256": "5efe48d255973902f6badc3ce55e2aa6c5c3b3bc642059ef3a91247bcfcc5806", + "urls": [ + "https://files.pythonhosted.org/packages/d6/f4/154cf374c2daf2020e05c3c6a03c91348d59b23c5366e968feb198306fdf/jeepney-0.8.0.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_keyring_py3_none_any_5426f817": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "keyring-25.4.1-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "keyring==25.4.1", + "sha256": "5426f817cf7f6f007ba5ec722b1bcad95a75b27d780343772ad76b17cb47b0bf", + "urls": [ + "https://files.pythonhosted.org/packages/83/25/e6d59e5f0a0508d0dca8bb98c7f7fd3772fc943ac3f53d5ab18a218d32c0/keyring-25.4.1-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_keyring_sdist_b07ebc55": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "keyring-25.4.1.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "keyring==25.4.1", + "sha256": "b07ebc55f3e8ed86ac81dd31ef14e81ace9dd9c3d4b5d77a6e9a2016d0d71a1b", + "urls": [ + "https://files.pythonhosted.org/packages/a5/1c/2bdbcfd5d59dc6274ffb175bc29aa07ecbfab196830e0cfbde7bd861a2ea/keyring-25.4.1.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_markdown_it_py_py3_none_any_35521684": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "markdown_it_py-3.0.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "markdown-it-py==3.0.0", + "sha256": "355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", + "urls": [ + "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_markdown_it_py_sdist_e3f60a94": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "markdown-it-py-3.0.0.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "markdown-it-py==3.0.0", + "sha256": "e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", + "urls": [ + "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_mdurl_py3_none_any_84008a41": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "mdurl-0.1.2-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "mdurl==0.1.2", + "sha256": "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", + "urls": [ + "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_mdurl_sdist_bb413d29": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "mdurl-0.1.2.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "mdurl==0.1.2", + "sha256": "bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", + "urls": [ + "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_more_itertools_py3_none_any_037b0d32": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "more_itertools-10.5.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "more-itertools==10.5.0", + "sha256": "037b0d3203ce90cca8ab1defbbdac29d5f993fc20131f3664dc8d6acfa872aef", + "urls": [ + "https://files.pythonhosted.org/packages/48/7e/3a64597054a70f7c86eb0a7d4fc315b8c1ab932f64883a297bdffeb5f967/more_itertools-10.5.0-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_more_itertools_sdist_5482bfef": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "more-itertools-10.5.0.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "more-itertools==10.5.0", + "sha256": "5482bfef7849c25dc3c6dd53a6173ae4795da2a41a80faea6700d9f5846c5da6", + "urls": [ + "https://files.pythonhosted.org/packages/51/78/65922308c4248e0eb08ebcbe67c95d48615cc6f27854b6f2e57143e9178f/more-itertools-10.5.0.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_nh3_cp37_abi3_macosx_10_12_x86_64_14c5a72e": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "nh3-0.2.18-cp37-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "nh3==0.2.18", + "sha256": "14c5a72e9fe82aea5fe3072116ad4661af5cf8e8ff8fc5ad3450f123e4925e86", + "urls": [ + "https://files.pythonhosted.org/packages/b3/89/1daff5d9ba5a95a157c092c7c5f39b8dd2b1ddb4559966f808d31cfb67e0/nh3-0.2.18-cp37-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl" + ] + } + }, + "rules_python_publish_deps_311_nh3_cp37_abi3_macosx_10_12_x86_64_7b7c2a3c": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "nh3-0.2.18-cp37-abi3-macosx_10_12_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "nh3==0.2.18", + "sha256": "7b7c2a3c9eb1a827d42539aa64091640bd275b81e097cd1d8d82ef91ffa2e811", + "urls": [ + "https://files.pythonhosted.org/packages/2c/b6/42fc3c69cabf86b6b81e4c051a9b6e249c5ba9f8155590222c2622961f58/nh3-0.2.18-cp37-abi3-macosx_10_12_x86_64.whl" + ] + } + }, + "rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_aarch64_42c64511": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "nh3-0.2.18-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "nh3==0.2.18", + "sha256": "42c64511469005058cd17cc1537578eac40ae9f7200bedcfd1fc1a05f4f8c200", + "urls": [ + "https://files.pythonhosted.org/packages/45/b9/833f385403abaf0023c6547389ec7a7acf141ddd9d1f21573723a6eab39a/nh3-0.2.18-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" + ] + } + }, + "rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_armv7l_0411beb0": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "nh3-0.2.18-cp37-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "nh3==0.2.18", + "sha256": "0411beb0589eacb6734f28d5497ca2ed379eafab8ad8c84b31bb5c34072b7164", + "urls": [ + "https://files.pythonhosted.org/packages/05/2b/85977d9e11713b5747595ee61f381bc820749daf83f07b90b6c9964cf932/nh3-0.2.18-cp37-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl" + ] + } + }, + "rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_ppc64_5f36b271": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "nh3-0.2.18-cp37-abi3-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "nh3==0.2.18", + "sha256": "5f36b271dae35c465ef5e9090e1fdaba4a60a56f0bb0ba03e0932a66f28b9189", + "urls": [ + "https://files.pythonhosted.org/packages/72/f2/5c894d5265ab80a97c68ca36f25c8f6f0308abac649aaf152b74e7e854a8/nh3-0.2.18-cp37-abi3-manylinux_2_17_ppc64.manylinux2014_ppc64.whl" + ] + } + }, + "rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_ppc64le_34c03fa7": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "nh3-0.2.18-cp37-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "nh3==0.2.18", + "sha256": "34c03fa78e328c691f982b7c03d4423bdfd7da69cd707fe572f544cf74ac23ad", + "urls": [ + "https://files.pythonhosted.org/packages/ab/a7/375afcc710dbe2d64cfbd69e31f82f3e423d43737258af01f6a56d844085/nh3-0.2.18-cp37-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl" + ] + } + }, + "rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_s390x_19aaba96": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "nh3-0.2.18-cp37-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "nh3==0.2.18", + "sha256": "19aaba96e0f795bd0a6c56291495ff59364f4300d4a39b29a0abc9cb3774a84b", + "urls": [ + "https://files.pythonhosted.org/packages/c2/a8/3bb02d0c60a03ad3a112b76c46971e9480efa98a8946677b5a59f60130ca/nh3-0.2.18-cp37-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl" + ] + } + }, + "rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_x86_64_de3ceed6": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "nh3-0.2.18-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "nh3==0.2.18", + "sha256": "de3ceed6e661954871d6cd78b410213bdcb136f79aafe22aa7182e028b8c7307", + "urls": [ + "https://files.pythonhosted.org/packages/1b/63/6ab90d0e5225ab9780f6c9fb52254fa36b52bb7c188df9201d05b647e5e1/nh3-0.2.18-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" + ] + } + }, + "rules_python_publish_deps_311_nh3_cp37_abi3_musllinux_1_2_aarch64_f0eca9ca": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "nh3-0.2.18-cp37-abi3-musllinux_1_2_aarch64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "nh3==0.2.18", + "sha256": "f0eca9ca8628dbb4e916ae2491d72957fdd35f7a5d326b7032a345f111ac07fe", + "urls": [ + "https://files.pythonhosted.org/packages/a3/da/0c4e282bc3cff4a0adf37005fa1fb42257673fbc1bbf7d1ff639ec3d255a/nh3-0.2.18-cp37-abi3-musllinux_1_2_aarch64.whl" + ] + } + }, + "rules_python_publish_deps_311_nh3_cp37_abi3_musllinux_1_2_armv7l_3a157ab1": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "nh3-0.2.18-cp37-abi3-musllinux_1_2_armv7l.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "nh3==0.2.18", + "sha256": "3a157ab149e591bb638a55c8c6bcb8cdb559c8b12c13a8affaba6cedfe51713a", + "urls": [ + "https://files.pythonhosted.org/packages/de/81/c291231463d21da5f8bba82c8167a6d6893cc5419b0639801ee5d3aeb8a9/nh3-0.2.18-cp37-abi3-musllinux_1_2_armv7l.whl" + ] + } + }, + "rules_python_publish_deps_311_nh3_cp37_abi3_musllinux_1_2_x86_64_36c95d4b": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "nh3-0.2.18-cp37-abi3-musllinux_1_2_x86_64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "nh3==0.2.18", + "sha256": "36c95d4b70530b320b365659bb5034341316e6a9b30f0b25fa9c9eff4c27a204", + "urls": [ + "https://files.pythonhosted.org/packages/eb/61/73a007c74c37895fdf66e0edcd881f5eaa17a348ff02f4bb4bc906d61085/nh3-0.2.18-cp37-abi3-musllinux_1_2_x86_64.whl" + ] + } + }, + "rules_python_publish_deps_311_nh3_cp37_abi3_win_amd64_8ce0f819": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "nh3-0.2.18-cp37-abi3-win_amd64.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "nh3==0.2.18", + "sha256": "8ce0f819d2f1933953fca255db2471ad58184a60508f03e6285e5114b6254844", + "urls": [ + "https://files.pythonhosted.org/packages/26/8d/53c5b19c4999bdc6ba95f246f4ef35ca83d7d7423e5e38be43ad66544e5d/nh3-0.2.18-cp37-abi3-win_amd64.whl" + ] + } + }, + "rules_python_publish_deps_311_nh3_sdist_94a16692": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "nh3-0.2.18.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "nh3==0.2.18", + "sha256": "94a166927e53972a9698af9542ace4e38b9de50c34352b962f4d9a7d4c927af4", + "urls": [ + "https://files.pythonhosted.org/packages/62/73/10df50b42ddb547a907deeb2f3c9823022580a7a47281e8eae8e003a9639/nh3-0.2.18.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_pkginfo_py3_none_any_889a6da2": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "pkginfo-1.10.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "pkginfo==1.10.0", + "sha256": "889a6da2ed7ffc58ab5b900d888ddce90bce912f2d2de1dc1c26f4cb9fe65097", + "urls": [ + "https://files.pythonhosted.org/packages/56/09/054aea9b7534a15ad38a363a2bd974c20646ab1582a387a95b8df1bfea1c/pkginfo-1.10.0-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_pkginfo_sdist_5df73835": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "pkginfo-1.10.0.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "pkginfo==1.10.0", + "sha256": "5df73835398d10db79f8eecd5cd86b1f6d29317589ea70796994d49399af6297", + "urls": [ + "https://files.pythonhosted.org/packages/2f/72/347ec5be4adc85c182ed2823d8d1c7b51e13b9a6b0c1aae59582eca652df/pkginfo-1.10.0.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_pycparser_py3_none_any_c3702b6d": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "filename": "pycparser-2.22-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "pycparser==2.22", + "sha256": "c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", + "urls": [ + "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_pycparser_sdist_491c8be9": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "pycparser-2.22.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "pycparser==2.22", + "sha256": "491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", + "urls": [ + "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_pygments_py3_none_any_b8e6aca0": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "pygments-2.18.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "pygments==2.18.0", + "sha256": "b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a", + "urls": [ + "https://files.pythonhosted.org/packages/f7/3f/01c8b82017c199075f8f788d0d906b9ffbbc5a47dc9918a945e13d5a2bda/pygments-2.18.0-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_pygments_sdist_786ff802": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "pygments-2.18.0.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "pygments==2.18.0", + "sha256": "786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199", + "urls": [ + "https://files.pythonhosted.org/packages/8e/62/8336eff65bcbc8e4cb5d05b55faf041285951b6e80f33e2bff2024788f31/pygments-2.18.0.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_pywin32_ctypes_py3_none_any_8a151337": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_windows_x86_64" + ], + "filename": "pywin32_ctypes-0.2.3-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "pywin32-ctypes==0.2.3", + "sha256": "8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", + "urls": [ + "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_pywin32_ctypes_sdist_d162dc04": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "pywin32-ctypes-0.2.3.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "pywin32-ctypes==0.2.3", + "sha256": "d162dc04946d704503b2edc4d55f3dba5c1d539ead017afa00142c38b9885755", + "urls": [ + "https://files.pythonhosted.org/packages/85/9f/01a1a99704853cb63f253eea009390c88e7131c67e66a0a02099a8c917cb/pywin32-ctypes-0.2.3.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_readme_renderer_py3_none_any_2fbca89b": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "readme_renderer-44.0-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "readme-renderer==44.0", + "sha256": "2fbca89b81a08526aadf1357a8c2ae889ec05fb03f5da67f9769c9a592166151", + "urls": [ + "https://files.pythonhosted.org/packages/e1/67/921ec3024056483db83953ae8e48079ad62b92db7880013ca77632921dd0/readme_renderer-44.0-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_readme_renderer_sdist_8712034e": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "readme_renderer-44.0.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "readme-renderer==44.0", + "sha256": "8712034eabbfa6805cacf1402b4eeb2a73028f72d1166d6f5cb7f9c047c5d1e1", + "urls": [ + "https://files.pythonhosted.org/packages/5a/a9/104ec9234c8448c4379768221ea6df01260cd6c2ce13182d4eac531c8342/readme_renderer-44.0.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_requests_py3_none_any_70761cfe": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "requests-2.32.3-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "requests==2.32.3", + "sha256": "70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", + "urls": [ + "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_requests_sdist_55365417": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "requests-2.32.3.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "requests==2.32.3", + "sha256": "55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", + "urls": [ + "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_requests_toolbelt_py2_none_any_cccfdd66": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "requests_toolbelt-1.0.0-py2.py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "requests-toolbelt==1.0.0", + "sha256": "cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", + "urls": [ + "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_requests_toolbelt_sdist_7681a0a3": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "requests-toolbelt-1.0.0.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "requests-toolbelt==1.0.0", + "sha256": "7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6", + "urls": [ + "https://files.pythonhosted.org/packages/f3/61/d7545dafb7ac2230c70d38d31cbfe4cc64f7144dc41f6e4e4b78ecd9f5bb/requests-toolbelt-1.0.0.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_rfc3986_py2_none_any_50b1502b": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "rfc3986-2.0.0-py2.py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "rfc3986==2.0.0", + "sha256": "50b1502b60e289cb37883f3dfd34532b8873c7de9f49bb546641ce9cbd256ebd", + "urls": [ + "https://files.pythonhosted.org/packages/ff/9a/9afaade874b2fa6c752c36f1548f718b5b83af81ed9b76628329dab81c1b/rfc3986-2.0.0-py2.py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_rfc3986_sdist_97aacf9d": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "rfc3986-2.0.0.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "rfc3986==2.0.0", + "sha256": "97aacf9dbd4bfd829baad6e6309fa6573aaf1be3f6fa735c8ab05e46cecb261c", + "urls": [ + "https://files.pythonhosted.org/packages/85/40/1520d68bfa07ab5a6f065a186815fb6610c86fe957bc065754e47f7b0840/rfc3986-2.0.0.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_rich_py3_none_any_6049d5e6": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "rich-13.9.4-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "rich==13.9.4", + "sha256": "6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90", + "urls": [ + "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_rich_sdist_43959497": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "rich-13.9.4.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "rich==13.9.4", + "sha256": "439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098", + "urls": [ + "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_secretstorage_py3_none_any_f356e662": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "filename": "SecretStorage-3.3.3-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "secretstorage==3.3.3", + "sha256": "f356e6628222568e3af06f2eba8df495efa13b3b63081dafd4f7d9a7b7bc9f99", + "urls": [ + "https://files.pythonhosted.org/packages/54/24/b4293291fa1dd830f353d2cb163295742fa87f179fcc8a20a306a81978b7/SecretStorage-3.3.3-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_secretstorage_sdist_2403533e": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "SecretStorage-3.3.3.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "secretstorage==3.3.3", + "sha256": "2403533ef369eca6d2ba81718576c5e0f564d5cca1b58f73a8b23e7d4eeebd77", + "urls": [ + "https://files.pythonhosted.org/packages/53/a4/f48c9d79cb507ed1373477dbceaba7401fd8a23af63b837fa61f1dcd3691/SecretStorage-3.3.3.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_twine_py3_none_any_215dbe7b": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "twine-5.1.1-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "twine==5.1.1", + "sha256": "215dbe7b4b94c2c50a7315c0275d2258399280fbb7d04182c7e55e24b5f93997", + "urls": [ + "https://files.pythonhosted.org/packages/5d/ec/00f9d5fd040ae29867355e559a94e9a8429225a0284a3f5f091a3878bfc0/twine-5.1.1-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_twine_sdist_9aa08251": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "twine-5.1.1.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "twine==5.1.1", + "sha256": "9aa0825139c02b3434d913545c7b847a21c835e11597f5255842d457da2322db", + "urls": [ + "https://files.pythonhosted.org/packages/77/68/bd982e5e949ef8334e6f7dcf76ae40922a8750aa2e347291ae1477a4782b/twine-5.1.1.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_urllib3_py3_none_any_ca899ca0": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "urllib3-2.2.3-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "urllib3==2.2.3", + "sha256": "ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac", + "urls": [ + "https://files.pythonhosted.org/packages/ce/d9/5f4c13cecde62396b0d3fe530a50ccea91e7dfc1ccf0e09c228841bb5ba8/urllib3-2.2.3-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_urllib3_sdist_e7d814a8": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "urllib3-2.2.3.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "urllib3==2.2.3", + "sha256": "e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9", + "urls": [ + "https://files.pythonhosted.org/packages/ed/63/22ba4ebfe7430b76388e7cd448d5478814d3032121827c12a2cc287e2260/urllib3-2.2.3.tar.gz" + ] + } + }, + "rules_python_publish_deps_311_zipp_py3_none_any_a817ac80": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "filename": "zipp-3.20.2-py3-none-any.whl", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "zipp==3.20.2", + "sha256": "a817ac80d6cf4b23bf7f2828b7cabf326f15a001bea8b1f9b49631780ba28350", + "urls": [ + "https://files.pythonhosted.org/packages/62/8b/5ba542fa83c90e09eac972fc9baca7a88e7e7ca4b221a89251954019308b/zipp-3.20.2-py3-none-any.whl" + ] + } + }, + "rules_python_publish_deps_311_zipp_sdist_bc9eb26f": { + "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", + "attributes": { + "dep_template": "@rules_python_publish_deps//{name}:{target}", + "experimental_target_platforms": [ + "cp311_linux_aarch64", + "cp311_linux_arm", + "cp311_linux_ppc", + "cp311_linux_s390x", + "cp311_linux_x86_64", + "cp311_osx_aarch64", + "cp311_osx_x86_64", + "cp311_windows_x86_64" + ], + "extra_pip_args": [ + "--index-url", + "https://pypi.org/simple" + ], + "filename": "zipp-3.20.2.tar.gz", + "python_interpreter_target": "@@+python+python_3_11_host//:python", + "repo": "rules_python_publish_deps_311", + "requirement": "zipp==3.20.2", + "sha256": "bc9eb26f4506fda01b81bcde0ca78103b6e62f991b381fec825435c836edbc29", + "urls": [ + "https://files.pythonhosted.org/packages/54/bf/5c0000c44ebc80123ecbdddba1f5dcd94a5ada602a9c225d84b5aaa55e86/zipp-3.20.2.tar.gz" + ] + } + }, + "dev_pip": { + "repoRuleId": "@@//python/private/pypi:hub_repository.bzl%hub_repository", + "attributes": { + "repo_name": "dev_pip", + "extra_hub_aliases": {}, + "whl_map": { + "absl_py": "{\"dev_pip_311_absl_py_py3_none_any_526a04ea\":[{\"filename\":\"absl_py-2.1.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_absl_py_py3_none_any_526a04ea\":[{\"filename\":\"absl_py-2.1.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "alabaster": "{\"dev_pip_311_alabaster_py3_none_any_fc678640\":[{\"filename\":\"alabaster-1.0.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_alabaster_py3_none_any_fc678640\":[{\"filename\":\"alabaster-1.0.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "astroid": "{\"dev_pip_311_astroid_py3_none_any_db676dc4\":[{\"filename\":\"astroid-3.3.6-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_astroid_py3_none_any_db676dc4\":[{\"filename\":\"astroid-3.3.6-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "babel": "{\"dev_pip_311_babel_py3_none_any_368b5b98\":[{\"filename\":\"babel-2.16.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_babel_py3_none_any_368b5b98\":[{\"filename\":\"babel-2.16.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "certifi": "{\"dev_pip_311_certifi_py3_none_any_922820b5\":[{\"filename\":\"certifi-2024.8.30-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_certifi_py3_none_any_922820b5\":[{\"filename\":\"certifi-2024.8.30-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "charset_normalizer": "{\"dev_pip_311_charset_normalizer_cp311_cp311_macosx_10_9_universal2_0d99dd8f\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_macosx_10_9_x86_64_c57516e5\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_macosx_11_0_arm64_6dba5d19\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_manylinux_2_17_aarch64_bf4475b8\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_manylinux_2_17_ppc64le_ce031db0\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_manylinux_2_17_s390x_8ff4e7cd\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_manylinux_2_17_x86_64_3710a975\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_musllinux_1_2_aarch64_47334db7\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_musllinux_1_2_ppc64le_f1a2f519\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_musllinux_1_2_s390x_63bc5c4a\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_musllinux_1_2_x86_64_bcb4f8ea\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_win_amd64_cee4373f\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_py3_none_any_fe9f97fe\":[{\"filename\":\"charset_normalizer-3.4.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_macosx_10_13_universal2_dd4eda17\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_universal2.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_macosx_10_13_x86_64_e9e3c4c9\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_macosx_11_0_arm64_92a7e36b\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-macosx_11_0_arm64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_manylinux_2_17_aarch64_54b6a92d\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_manylinux_2_17_ppc64le_1ffd9493\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_manylinux_2_17_s390x_35c404d7\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_manylinux_2_17_x86_64_4796efc4\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_musllinux_1_2_aarch64_92db3c28\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_aarch64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_musllinux_1_2_ppc64le_4b67fdab\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_musllinux_1_2_s390x_aa41e526\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_s390x.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_musllinux_1_2_x86_64_ffc51962\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_win_amd64_707b82d1\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-win_amd64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_py3_none_any_fe9f97fe\":[{\"filename\":\"charset_normalizer-3.4.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "colorama": "{\"dev_pip_311_colorama_py2_none_any_4f1d9991\":[{\"filename\":\"colorama-0.4.6-py2.py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_colorama_py2_none_any_4f1d9991\":[{\"filename\":\"colorama-0.4.6-py2.py3-none-any.whl\",\"version\":\"3.13\"}]}", + "docutils": "{\"dev_pip_311_docutils_py3_none_any_dafca5b9\":[{\"filename\":\"docutils-0.21.2-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_docutils_py3_none_any_dafca5b9\":[{\"filename\":\"docutils-0.21.2-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "idna": "{\"dev_pip_311_idna_py3_none_any_946d195a\":[{\"filename\":\"idna-3.10-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_idna_py3_none_any_946d195a\":[{\"filename\":\"idna-3.10-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "imagesize": "{\"dev_pip_311_imagesize_py2_none_any_0d8d18d0\":[{\"filename\":\"imagesize-1.4.1-py2.py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_imagesize_py2_none_any_0d8d18d0\":[{\"filename\":\"imagesize-1.4.1-py2.py3-none-any.whl\",\"version\":\"3.13\"}]}", + "jinja2": "{\"dev_pip_311_jinja2_py3_none_any_bc5dd2ab\":[{\"filename\":\"jinja2-3.1.4-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_jinja2_py3_none_any_bc5dd2ab\":[{\"filename\":\"jinja2-3.1.4-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "markdown_it_py": "{\"dev_pip_311_markdown_it_py_py3_none_any_35521684\":[{\"filename\":\"markdown_it_py-3.0.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_markdown_it_py_py3_none_any_35521684\":[{\"filename\":\"markdown_it_py-3.0.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "markupsafe": "{\"dev_pip_311_markupsafe_cp311_cp311_macosx_10_9_universal2_9025b401\":[{\"filename\":\"MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl\",\"version\":\"3.11\"}],\"dev_pip_311_markupsafe_cp311_cp311_macosx_11_0_arm64_93335ca3\":[{\"filename\":\"MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_markupsafe_cp311_cp311_manylinux_2_17_aarch64_2cb8438c\":[{\"filename\":\"MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_markupsafe_cp311_cp311_manylinux_2_17_x86_64_a123e330\":[{\"filename\":\"MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_markupsafe_cp311_cp311_musllinux_1_2_aarch64_d8213e09\":[{\"filename\":\"MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_markupsafe_cp311_cp311_musllinux_1_2_x86_64_0bff5e0a\":[{\"filename\":\"MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_markupsafe_cp311_cp311_win_amd64_70a87b41\":[{\"filename\":\"MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl\",\"version\":\"3.11\"}],\"dev_pip_313_markupsafe_cp313_cp313_macosx_10_13_universal2_ba9527cd\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313_macosx_11_0_arm64_f8b3d067\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313_manylinux_2_17_aarch64_569511d3\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313_manylinux_2_17_x86_64_15ab75ef\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313_musllinux_1_2_aarch64_cdb82a87\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313_musllinux_1_2_x86_64_444dcda7\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313_win_amd64_e6a2a455\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313t_macosx_10_13_universal2_b5a6b3ad\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313t_macosx_11_0_arm64_a904af0a\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313t_manylinux_2_17_aarch64_4aa4e5fa\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313t_manylinux_2_17_x86_64_c0ef13ea\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313t_musllinux_1_2_aarch64_6381026f\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313t_musllinux_1_2_x86_64_131a3c76\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313t_win_amd64_e444a31f\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl\",\"version\":\"3.13\"}]}", + "mdit_py_plugins": "{\"dev_pip_311_mdit_py_plugins_py3_none_any_0c673c3f\":[{\"filename\":\"mdit_py_plugins-0.4.2-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_mdit_py_plugins_py3_none_any_0c673c3f\":[{\"filename\":\"mdit_py_plugins-0.4.2-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "mdurl": "{\"dev_pip_311_mdurl_py3_none_any_84008a41\":[{\"filename\":\"mdurl-0.1.2-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_mdurl_py3_none_any_84008a41\":[{\"filename\":\"mdurl-0.1.2-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "myst_parser": "{\"dev_pip_311_myst_parser_py3_none_any_b9317997\":[{\"filename\":\"myst_parser-4.0.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_myst_parser_py3_none_any_b9317997\":[{\"filename\":\"myst_parser-4.0.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "packaging": "{\"dev_pip_311_packaging_py3_none_any_5b8f2217\":[{\"filename\":\"packaging-24.1-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_packaging_py3_none_any_5b8f2217\":[{\"filename\":\"packaging-24.1-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "pygments": "{\"dev_pip_311_pygments_py3_none_any_b8e6aca0\":[{\"filename\":\"pygments-2.18.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_pygments_py3_none_any_b8e6aca0\":[{\"filename\":\"pygments-2.18.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "pyyaml": "{\"dev_pip_311_pyyaml_cp311_cp311_macosx_10_9_x86_64_cc1c1159\":[{\"filename\":\"PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_pyyaml_cp311_cp311_macosx_11_0_arm64_1e2120ef\":[{\"filename\":\"PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_pyyaml_cp311_cp311_manylinux_2_17_aarch64_5d225db5\":[{\"filename\":\"PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_pyyaml_cp311_cp311_manylinux_2_17_s390x_5ac9328e\":[{\"filename\":\"PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl\",\"version\":\"3.11\"}],\"dev_pip_311_pyyaml_cp311_cp311_manylinux_2_17_x86_64_3ad2a3de\":[{\"filename\":\"PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_pyyaml_cp311_cp311_musllinux_1_1_aarch64_ff3824dc\":[{\"filename\":\"PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_pyyaml_cp311_cp311_musllinux_1_1_x86_64_797b4f72\":[{\"filename\":\"PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_pyyaml_cp311_cp311_win_amd64_e10ce637\":[{\"filename\":\"PyYAML-6.0.2-cp311-cp311-win_amd64.whl\",\"version\":\"3.11\"}],\"dev_pip_313_pyyaml_cp313_cp313_macosx_10_13_x86_64_efdca563\":[{\"filename\":\"PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_pyyaml_cp313_cp313_macosx_11_0_arm64_50187695\":[{\"filename\":\"PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_pyyaml_cp313_cp313_manylinux_2_17_aarch64_0ffe8360\":[{\"filename\":\"PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_pyyaml_cp313_cp313_manylinux_2_17_s390x_17e311b6\":[{\"filename\":\"PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl\",\"version\":\"3.13\"}],\"dev_pip_313_pyyaml_cp313_cp313_manylinux_2_17_x86_64_70b18959\":[{\"filename\":\"PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_pyyaml_cp313_cp313_musllinux_1_1_aarch64_41e4e395\":[{\"filename\":\"PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_pyyaml_cp313_cp313_musllinux_1_1_x86_64_68ccc602\":[{\"filename\":\"PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_pyyaml_cp313_cp313_win_amd64_8388ee19\":[{\"filename\":\"PyYAML-6.0.2-cp313-cp313-win_amd64.whl\",\"version\":\"3.13\"}]}", + "readthedocs_sphinx_ext": "{\"dev_pip_311_readthedocs_sphinx_ext_py2_none_any_f8c56184\":[{\"filename\":\"readthedocs_sphinx_ext-2.2.5-py2.py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_readthedocs_sphinx_ext_py2_none_any_f8c56184\":[{\"filename\":\"readthedocs_sphinx_ext-2.2.5-py2.py3-none-any.whl\",\"version\":\"3.13\"}]}", + "requests": "{\"dev_pip_311_requests_py3_none_any_70761cfe\":[{\"filename\":\"requests-2.32.3-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_requests_py3_none_any_70761cfe\":[{\"filename\":\"requests-2.32.3-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "snowballstemmer": "{\"dev_pip_311_snowballstemmer_py2_none_any_c8e1716e\":[{\"filename\":\"snowballstemmer-2.2.0-py2.py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_snowballstemmer_py2_none_any_c8e1716e\":[{\"filename\":\"snowballstemmer-2.2.0-py2.py3-none-any.whl\",\"version\":\"3.13\"}]}", + "sphinx": "{\"dev_pip_311_sphinx_py3_none_any_09719015\":[{\"filename\":\"sphinx-8.1.3-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinx_py3_none_any_09719015\":[{\"filename\":\"sphinx-8.1.3-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "sphinx_autodoc2": "{\"dev_pip_311_sphinx_autodoc2_py3_none_any_e867013b\":[{\"filename\":\"sphinx_autodoc2-0.5.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinx_autodoc2_py3_none_any_e867013b\":[{\"filename\":\"sphinx_autodoc2-0.5.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "sphinx_reredirects": "{\"dev_pip_311_sphinx_reredirects_py3_none_any_444ae143\":[{\"filename\":\"sphinx_reredirects-0.1.5-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinx_reredirects_py3_none_any_444ae143\":[{\"filename\":\"sphinx_reredirects-0.1.5-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "sphinx_rtd_theme": "{\"dev_pip_311_sphinx_rtd_theme_py2_none_any_921c0ece\":[{\"filename\":\"sphinx_rtd_theme-3.0.1-py2.py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinx_rtd_theme_py2_none_any_921c0ece\":[{\"filename\":\"sphinx_rtd_theme-3.0.1-py2.py3-none-any.whl\",\"version\":\"3.13\"}]}", + "sphinxcontrib_applehelp": "{\"dev_pip_311_sphinxcontrib_applehelp_py3_none_any_4cd3f0ec\":[{\"filename\":\"sphinxcontrib_applehelp-2.0.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinxcontrib_applehelp_py3_none_any_4cd3f0ec\":[{\"filename\":\"sphinxcontrib_applehelp-2.0.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "sphinxcontrib_devhelp": "{\"dev_pip_311_sphinxcontrib_devhelp_py3_none_any_aefb8b83\":[{\"filename\":\"sphinxcontrib_devhelp-2.0.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinxcontrib_devhelp_py3_none_any_aefb8b83\":[{\"filename\":\"sphinxcontrib_devhelp-2.0.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "sphinxcontrib_htmlhelp": "{\"dev_pip_311_sphinxcontrib_htmlhelp_py3_none_any_16675982\":[{\"filename\":\"sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinxcontrib_htmlhelp_py3_none_any_16675982\":[{\"filename\":\"sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "sphinxcontrib_jquery": "{\"dev_pip_311_sphinxcontrib_jquery_py2_none_any_f936030d\":[{\"filename\":\"sphinxcontrib_jquery-4.1-py2.py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinxcontrib_jquery_py2_none_any_f936030d\":[{\"filename\":\"sphinxcontrib_jquery-4.1-py2.py3-none-any.whl\",\"version\":\"3.13\"}]}", + "sphinxcontrib_jsmath": "{\"dev_pip_311_sphinxcontrib_jsmath_py2_none_any_2ec2eaeb\":[{\"filename\":\"sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinxcontrib_jsmath_py2_none_any_2ec2eaeb\":[{\"filename\":\"sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl\",\"version\":\"3.13\"}]}", + "sphinxcontrib_qthelp": "{\"dev_pip_311_sphinxcontrib_qthelp_py3_none_any_b18a828c\":[{\"filename\":\"sphinxcontrib_qthelp-2.0.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinxcontrib_qthelp_py3_none_any_b18a828c\":[{\"filename\":\"sphinxcontrib_qthelp-2.0.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "sphinxcontrib_serializinghtml": "{\"dev_pip_311_sphinxcontrib_serializinghtml_py3_none_any_6e2cb0ee\":[{\"filename\":\"sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinxcontrib_serializinghtml_py3_none_any_6e2cb0ee\":[{\"filename\":\"sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "typing_extensions": "{\"dev_pip_311_typing_extensions_py3_none_any_04e5ca03\":[{\"filename\":\"typing_extensions-4.12.2-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_typing_extensions_py3_none_any_04e5ca03\":[{\"filename\":\"typing_extensions-4.12.2-py3-none-any.whl\",\"version\":\"3.13\"}]}", + "urllib3": "{\"dev_pip_311_urllib3_py3_none_any_ca899ca0\":[{\"filename\":\"urllib3-2.2.3-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_urllib3_py3_none_any_ca899ca0\":[{\"filename\":\"urllib3-2.2.3-py3-none-any.whl\",\"version\":\"3.13\"}]}" + }, + "packages": [ + "absl_py", + "alabaster", + "astroid", + "babel", + "certifi", + "charset_normalizer", + "docutils", + "idna", + "imagesize", + "jinja2", + "markdown_it_py", + "markupsafe", + "mdit_py_plugins", + "mdurl", + "myst_parser", + "packaging", + "pygments", + "pyyaml", + "readthedocs_sphinx_ext", + "requests", + "snowballstemmer", + "sphinx", + "sphinx_autodoc2", + "sphinx_reredirects", + "sphinx_rtd_theme", + "sphinxcontrib_applehelp", + "sphinxcontrib_devhelp", + "sphinxcontrib_htmlhelp", + "sphinxcontrib_jquery", + "sphinxcontrib_jsmath", + "sphinxcontrib_qthelp", + "sphinxcontrib_serializinghtml", + "typing_extensions", + "urllib3" + ], + "groups": {} + } + }, + "pip_deps": { + "repoRuleId": "@@//python/private/pypi:hub_repository.bzl%hub_repository", + "attributes": { + "repo_name": "pip_deps", + "extra_hub_aliases": {}, + "whl_map": { + "numpy": "{\"pip_deps_310_numpy\":[{\"version\":\"3.10\"}],\"pip_deps_311_numpy\":[{\"version\":\"3.11\"}],\"pip_deps_312_numpy\":[{\"version\":\"3.12\"}],\"pip_deps_38_numpy\":[{\"version\":\"3.8\"}],\"pip_deps_39_numpy\":[{\"version\":\"3.9\"}]}", + "setuptools": "{\"pip_deps_310_setuptools\":[{\"version\":\"3.10\"}],\"pip_deps_311_setuptools\":[{\"version\":\"3.11\"}],\"pip_deps_312_setuptools\":[{\"version\":\"3.12\"}],\"pip_deps_38_setuptools\":[{\"version\":\"3.8\"}],\"pip_deps_39_setuptools\":[{\"version\":\"3.9\"}]}" + }, + "packages": [ + "numpy", + "setuptools" + ], + "groups": {} + } + }, + "pypiserver": { + "repoRuleId": "@@//python/private/pypi:hub_repository.bzl%hub_repository", + "attributes": { + "repo_name": "pypiserver", + "extra_hub_aliases": {}, + "whl_map": { + "pip": "{\"pypiserver_311_pip_py3_none_any_ba0d021a\":[{\"filename\":\"pip-24.0-py3-none-any.whl\",\"version\":\"3.11\"}]}", + "pypiserver": "{\"pypiserver_311_pypiserver_py2_none_any_1dd98fb9\":[{\"filename\":\"pypiserver-2.0.1-py2.py3-none-any.whl\",\"version\":\"3.11\"}]}" + }, + "packages": [ + "pip", + "pypiserver" + ], + "groups": {} + } + }, + "rules_fuzzing_py_deps": { + "repoRuleId": "@@//python/private/pypi:hub_repository.bzl%hub_repository", + "attributes": { + "repo_name": "rules_fuzzing_py_deps", + "extra_hub_aliases": {}, + "whl_map": { + "absl_py": "{\"rules_fuzzing_py_deps_310_absl_py\":[{\"version\":\"3.10\"}],\"rules_fuzzing_py_deps_311_absl_py\":[{\"version\":\"3.11\"}],\"rules_fuzzing_py_deps_312_absl_py\":[{\"version\":\"3.12\"}],\"rules_fuzzing_py_deps_38_absl_py\":[{\"version\":\"3.8\"}],\"rules_fuzzing_py_deps_39_absl_py\":[{\"version\":\"3.9\"}]}", + "six": "{\"rules_fuzzing_py_deps_310_six\":[{\"version\":\"3.10\"}],\"rules_fuzzing_py_deps_311_six\":[{\"version\":\"3.11\"}],\"rules_fuzzing_py_deps_312_six\":[{\"version\":\"3.12\"}],\"rules_fuzzing_py_deps_38_six\":[{\"version\":\"3.8\"}],\"rules_fuzzing_py_deps_39_six\":[{\"version\":\"3.9\"}]}" + }, + "packages": [ + "absl_py", + "six" + ], + "groups": {} + } + }, + "rules_python_publish_deps": { + "repoRuleId": "@@//python/private/pypi:hub_repository.bzl%hub_repository", + "attributes": { + "repo_name": "rules_python_publish_deps", + "extra_hub_aliases": {}, + "whl_map": { + "backports_tarfile": "{\"rules_python_publish_deps_311_backports_tarfile_py3_none_any_77e284d7\":[{\"filename\":\"backports.tarfile-1.2.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_backports_tarfile_sdist_d75e02c2\":[{\"filename\":\"backports_tarfile-1.2.0.tar.gz\",\"version\":\"3.11\"}]}", + "certifi": "{\"rules_python_publish_deps_311_certifi_py3_none_any_922820b5\":[{\"filename\":\"certifi-2024.8.30-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_certifi_sdist_bec941d2\":[{\"filename\":\"certifi-2024.8.30.tar.gz\",\"version\":\"3.11\"}]}", + "cffi": "{\"rules_python_publish_deps_311_cffi_cp311_cp311_manylinux_2_17_aarch64_a1ed2dd2\":[{\"filename\":\"cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cffi_cp311_cp311_manylinux_2_17_ppc64le_46bf4316\":[{\"filename\":\"cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cffi_cp311_cp311_manylinux_2_17_s390x_a24ed04c\":[{\"filename\":\"cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cffi_cp311_cp311_manylinux_2_17_x86_64_610faea7\":[{\"filename\":\"cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cffi_cp311_cp311_musllinux_1_1_aarch64_a9b15d49\":[{\"filename\":\"cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cffi_cp311_cp311_musllinux_1_1_x86_64_fc48c783\":[{\"filename\":\"cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cffi_sdist_1c39c601\":[{\"filename\":\"cffi-1.17.1.tar.gz\",\"version\":\"3.11\"}]}", + "charset_normalizer": "{\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_macosx_10_9_universal2_0d99dd8f\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_macosx_10_9_x86_64_c57516e5\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_macosx_11_0_arm64_6dba5d19\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_manylinux_2_17_aarch64_bf4475b8\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_manylinux_2_17_ppc64le_ce031db0\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_manylinux_2_17_s390x_8ff4e7cd\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_manylinux_2_17_x86_64_3710a975\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_musllinux_1_2_aarch64_47334db7\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_musllinux_1_2_ppc64le_f1a2f519\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_musllinux_1_2_s390x_63bc5c4a\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_musllinux_1_2_x86_64_bcb4f8ea\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_win_amd64_cee4373f\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_py3_none_any_fe9f97fe\":[{\"filename\":\"charset_normalizer-3.4.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_sdist_223217c3\":[{\"filename\":\"charset_normalizer-3.4.0.tar.gz\",\"version\":\"3.11\"}]}", + "cryptography": "{\"rules_python_publish_deps_311_cryptography_cp39_abi3_manylinux_2_17_aarch64_846da004\":[{\"filename\":\"cryptography-43.0.3-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cryptography_cp39_abi3_manylinux_2_17_x86_64_0f996e72\":[{\"filename\":\"cryptography-43.0.3-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cryptography_cp39_abi3_manylinux_2_28_aarch64_f7b178f1\":[{\"filename\":\"cryptography-43.0.3-cp39-abi3-manylinux_2_28_aarch64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cryptography_cp39_abi3_manylinux_2_28_x86_64_c2e6fc39\":[{\"filename\":\"cryptography-43.0.3-cp39-abi3-manylinux_2_28_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cryptography_cp39_abi3_musllinux_1_2_aarch64_e1be4655\":[{\"filename\":\"cryptography-43.0.3-cp39-abi3-musllinux_1_2_aarch64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cryptography_cp39_abi3_musllinux_1_2_x86_64_df6b6c6d\":[{\"filename\":\"cryptography-43.0.3-cp39-abi3-musllinux_1_2_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cryptography_sdist_315b9001\":[{\"filename\":\"cryptography-43.0.3.tar.gz\",\"version\":\"3.11\"}]}", + "docutils": "{\"rules_python_publish_deps_311_docutils_py3_none_any_dafca5b9\":[{\"filename\":\"docutils-0.21.2-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_docutils_sdist_3a6b1873\":[{\"filename\":\"docutils-0.21.2.tar.gz\",\"version\":\"3.11\"}]}", + "idna": "{\"rules_python_publish_deps_311_idna_py3_none_any_946d195a\":[{\"filename\":\"idna-3.10-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_idna_sdist_12f65c9b\":[{\"filename\":\"idna-3.10.tar.gz\",\"version\":\"3.11\"}]}", + "importlib_metadata": "{\"rules_python_publish_deps_311_importlib_metadata_py3_none_any_45e54197\":[{\"filename\":\"importlib_metadata-8.5.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_importlib_metadata_sdist_71522656\":[{\"filename\":\"importlib_metadata-8.5.0.tar.gz\",\"version\":\"3.11\"}]}", + "jaraco_classes": "{\"rules_python_publish_deps_311_jaraco_classes_py3_none_any_f662826b\":[{\"filename\":\"jaraco.classes-3.4.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_jaraco_classes_sdist_47a024b5\":[{\"filename\":\"jaraco.classes-3.4.0.tar.gz\",\"version\":\"3.11\"}]}", + "jaraco_context": "{\"rules_python_publish_deps_311_jaraco_context_py3_none_any_f797fc48\":[{\"filename\":\"jaraco.context-6.0.1-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_jaraco_context_sdist_9bae4ea5\":[{\"filename\":\"jaraco_context-6.0.1.tar.gz\",\"version\":\"3.11\"}]}", + "jaraco_functools": "{\"rules_python_publish_deps_311_jaraco_functools_py3_none_any_ad159f13\":[{\"filename\":\"jaraco.functools-4.1.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_jaraco_functools_sdist_70f7e0e2\":[{\"filename\":\"jaraco_functools-4.1.0.tar.gz\",\"version\":\"3.11\"}]}", + "jeepney": "{\"rules_python_publish_deps_311_jeepney_py3_none_any_c0a454ad\":[{\"filename\":\"jeepney-0.8.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_jeepney_sdist_5efe48d2\":[{\"filename\":\"jeepney-0.8.0.tar.gz\",\"version\":\"3.11\"}]}", + "keyring": "{\"rules_python_publish_deps_311_keyring_py3_none_any_5426f817\":[{\"filename\":\"keyring-25.4.1-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_keyring_sdist_b07ebc55\":[{\"filename\":\"keyring-25.4.1.tar.gz\",\"version\":\"3.11\"}]}", + "markdown_it_py": "{\"rules_python_publish_deps_311_markdown_it_py_py3_none_any_35521684\":[{\"filename\":\"markdown_it_py-3.0.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_markdown_it_py_sdist_e3f60a94\":[{\"filename\":\"markdown-it-py-3.0.0.tar.gz\",\"version\":\"3.11\"}]}", + "mdurl": "{\"rules_python_publish_deps_311_mdurl_py3_none_any_84008a41\":[{\"filename\":\"mdurl-0.1.2-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_mdurl_sdist_bb413d29\":[{\"filename\":\"mdurl-0.1.2.tar.gz\",\"version\":\"3.11\"}]}", + "more_itertools": "{\"rules_python_publish_deps_311_more_itertools_py3_none_any_037b0d32\":[{\"filename\":\"more_itertools-10.5.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_more_itertools_sdist_5482bfef\":[{\"filename\":\"more-itertools-10.5.0.tar.gz\",\"version\":\"3.11\"}]}", + "nh3": "{\"rules_python_publish_deps_311_nh3_cp37_abi3_macosx_10_12_x86_64_14c5a72e\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_macosx_10_12_x86_64_7b7c2a3c\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-macosx_10_12_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_aarch64_42c64511\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_armv7l_0411beb0\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_ppc64_5f36b271\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-manylinux_2_17_ppc64.manylinux2014_ppc64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_ppc64le_34c03fa7\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_s390x_19aaba96\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_x86_64_de3ceed6\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_musllinux_1_2_aarch64_f0eca9ca\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-musllinux_1_2_aarch64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_musllinux_1_2_armv7l_3a157ab1\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-musllinux_1_2_armv7l.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_musllinux_1_2_x86_64_36c95d4b\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-musllinux_1_2_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_win_amd64_8ce0f819\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-win_amd64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_sdist_94a16692\":[{\"filename\":\"nh3-0.2.18.tar.gz\",\"version\":\"3.11\"}]}", + "pkginfo": "{\"rules_python_publish_deps_311_pkginfo_py3_none_any_889a6da2\":[{\"filename\":\"pkginfo-1.10.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_pkginfo_sdist_5df73835\":[{\"filename\":\"pkginfo-1.10.0.tar.gz\",\"version\":\"3.11\"}]}", + "pycparser": "{\"rules_python_publish_deps_311_pycparser_py3_none_any_c3702b6d\":[{\"filename\":\"pycparser-2.22-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_pycparser_sdist_491c8be9\":[{\"filename\":\"pycparser-2.22.tar.gz\",\"version\":\"3.11\"}]}", + "pygments": "{\"rules_python_publish_deps_311_pygments_py3_none_any_b8e6aca0\":[{\"filename\":\"pygments-2.18.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_pygments_sdist_786ff802\":[{\"filename\":\"pygments-2.18.0.tar.gz\",\"version\":\"3.11\"}]}", + "pywin32_ctypes": "{\"rules_python_publish_deps_311_pywin32_ctypes_py3_none_any_8a151337\":[{\"filename\":\"pywin32_ctypes-0.2.3-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_pywin32_ctypes_sdist_d162dc04\":[{\"filename\":\"pywin32-ctypes-0.2.3.tar.gz\",\"version\":\"3.11\"}]}", + "readme_renderer": "{\"rules_python_publish_deps_311_readme_renderer_py3_none_any_2fbca89b\":[{\"filename\":\"readme_renderer-44.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_readme_renderer_sdist_8712034e\":[{\"filename\":\"readme_renderer-44.0.tar.gz\",\"version\":\"3.11\"}]}", + "requests": "{\"rules_python_publish_deps_311_requests_py3_none_any_70761cfe\":[{\"filename\":\"requests-2.32.3-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_requests_sdist_55365417\":[{\"filename\":\"requests-2.32.3.tar.gz\",\"version\":\"3.11\"}]}", + "requests_toolbelt": "{\"rules_python_publish_deps_311_requests_toolbelt_py2_none_any_cccfdd66\":[{\"filename\":\"requests_toolbelt-1.0.0-py2.py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_requests_toolbelt_sdist_7681a0a3\":[{\"filename\":\"requests-toolbelt-1.0.0.tar.gz\",\"version\":\"3.11\"}]}", + "rfc3986": "{\"rules_python_publish_deps_311_rfc3986_py2_none_any_50b1502b\":[{\"filename\":\"rfc3986-2.0.0-py2.py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_rfc3986_sdist_97aacf9d\":[{\"filename\":\"rfc3986-2.0.0.tar.gz\",\"version\":\"3.11\"}]}", + "rich": "{\"rules_python_publish_deps_311_rich_py3_none_any_6049d5e6\":[{\"filename\":\"rich-13.9.4-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_rich_sdist_43959497\":[{\"filename\":\"rich-13.9.4.tar.gz\",\"version\":\"3.11\"}]}", + "secretstorage": "{\"rules_python_publish_deps_311_secretstorage_py3_none_any_f356e662\":[{\"filename\":\"SecretStorage-3.3.3-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_secretstorage_sdist_2403533e\":[{\"filename\":\"SecretStorage-3.3.3.tar.gz\",\"version\":\"3.11\"}]}", + "twine": "{\"rules_python_publish_deps_311_twine_py3_none_any_215dbe7b\":[{\"filename\":\"twine-5.1.1-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_twine_sdist_9aa08251\":[{\"filename\":\"twine-5.1.1.tar.gz\",\"version\":\"3.11\"}]}", + "urllib3": "{\"rules_python_publish_deps_311_urllib3_py3_none_any_ca899ca0\":[{\"filename\":\"urllib3-2.2.3-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_urllib3_sdist_e7d814a8\":[{\"filename\":\"urllib3-2.2.3.tar.gz\",\"version\":\"3.11\"}]}", + "zipp": "{\"rules_python_publish_deps_311_zipp_py3_none_any_a817ac80\":[{\"filename\":\"zipp-3.20.2-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_zipp_sdist_bc9eb26f\":[{\"filename\":\"zipp-3.20.2.tar.gz\",\"version\":\"3.11\"}]}" + }, + "packages": [ + "backports_tarfile", + "certifi", + "charset_normalizer", + "docutils", + "idna", + "importlib_metadata", + "jaraco_classes", + "jaraco_context", + "jaraco_functools", + "keyring", + "markdown_it_py", + "mdurl", + "more_itertools", + "nh3", + "pkginfo", + "pygments", + "readme_renderer", + "requests", + "requests_toolbelt", + "rfc3986", + "rich", + "twine", + "urllib3", + "zipp" + ], + "groups": {} + } + } + }, + "moduleExtensionMetadata": { + "useAllRepos": "NO", + "reproducible": false + }, + "recordedRepoMappingEntries": [ + [ + "", + "bazel_features", + "bazel_features+" + ], + [ + "", + "bazel_skylib", + "bazel_skylib+" + ], + [ + "", + "bazel_tools", + "bazel_tools" + ], + [ + "", + "pypi__build", + "+internal_deps+pypi__build" + ], + [ + "", + "pypi__click", + "+internal_deps+pypi__click" + ], + [ + "", + "pypi__colorama", + "+internal_deps+pypi__colorama" + ], + [ + "", + "pypi__importlib_metadata", + "+internal_deps+pypi__importlib_metadata" + ], + [ + "", + "pypi__installer", + "+internal_deps+pypi__installer" + ], + [ + "", + "pypi__more_itertools", + "+internal_deps+pypi__more_itertools" + ], + [ + "", + "pypi__packaging", + "+internal_deps+pypi__packaging" + ], + [ + "", + "pypi__pep517", + "+internal_deps+pypi__pep517" + ], + [ + "", + "pypi__pip", + "+internal_deps+pypi__pip" + ], + [ + "", + "pypi__pip_tools", + "+internal_deps+pypi__pip_tools" + ], + [ + "", + "pypi__pyproject_hooks", + "+internal_deps+pypi__pyproject_hooks" + ], + [ + "", + "pypi__setuptools", + "+internal_deps+pypi__setuptools" + ], + [ + "", + "pypi__tomli", + "+internal_deps+pypi__tomli" + ], + [ + "", + "pypi__wheel", + "+internal_deps+pypi__wheel" + ], + [ + "", + "pypi__zipp", + "+internal_deps+pypi__zipp" + ], + [ + "", + "pythons_hub", + "+python+pythons_hub" + ], + [ + "+python+pythons_hub", + "python_3_10_11_host", + "+python+python_3_10_11_host" + ], + [ + "+python+pythons_hub", + "python_3_10_12_host", + "+python+python_3_10_12_host" + ], + [ + "+python+pythons_hub", + "python_3_10_13_host", + "+python+python_3_10_13_host" + ], + [ + "+python+pythons_hub", + "python_3_10_14_host", + "+python+python_3_10_14_host" + ], + [ + "+python+pythons_hub", + "python_3_10_15_host", + "+python+python_3_10_15_host" + ], + [ + "+python+pythons_hub", + "python_3_10_16_host", + "+python+python_3_10_16_host" + ], + [ + "+python+pythons_hub", + "python_3_10_2_host", + "+python+python_3_10_2_host" + ], + [ + "+python+pythons_hub", + "python_3_10_4_host", + "+python+python_3_10_4_host" + ], + [ + "+python+pythons_hub", + "python_3_10_6_host", + "+python+python_3_10_6_host" + ], + [ + "+python+pythons_hub", + "python_3_10_8_host", + "+python+python_3_10_8_host" + ], + [ + "+python+pythons_hub", + "python_3_10_9_host", + "+python+python_3_10_9_host" + ], + [ + "+python+pythons_hub", + "python_3_10_host", + "+python+python_3_10_host" + ], + [ + "+python+pythons_hub", + "python_3_11_10_host", + "+python+python_3_11_10_host" + ], + [ + "+python+pythons_hub", + "python_3_11_11_host", + "+python+python_3_11_11_host" + ], + [ + "+python+pythons_hub", + "python_3_11_1_host", + "+python+python_3_11_1_host" + ], + [ + "+python+pythons_hub", + "python_3_11_3_host", + "+python+python_3_11_3_host" + ], + [ + "+python+pythons_hub", + "python_3_11_4_host", + "+python+python_3_11_4_host" + ], + [ + "+python+pythons_hub", + "python_3_11_5_host", + "+python+python_3_11_5_host" + ], + [ + "+python+pythons_hub", + "python_3_11_6_host", + "+python+python_3_11_6_host" + ], + [ + "+python+pythons_hub", + "python_3_11_7_host", + "+python+python_3_11_7_host" + ], + [ + "+python+pythons_hub", + "python_3_11_8_host", + "+python+python_3_11_8_host" + ], + [ + "+python+pythons_hub", + "python_3_11_9_host", + "+python+python_3_11_9_host" + ], + [ + "+python+pythons_hub", + "python_3_11_host", + "+python+python_3_11_host" + ], + [ + "+python+pythons_hub", + "python_3_12_0_host", + "+python+python_3_12_0_host" + ], + [ + "+python+pythons_hub", + "python_3_12_1_host", + "+python+python_3_12_1_host" + ], + [ + "+python+pythons_hub", + "python_3_12_2_host", + "+python+python_3_12_2_host" + ], + [ + "+python+pythons_hub", + "python_3_12_3_host", + "+python+python_3_12_3_host" + ], + [ + "+python+pythons_hub", + "python_3_12_4_host", + "+python+python_3_12_4_host" + ], + [ + "+python+pythons_hub", + "python_3_12_7_host", + "+python+python_3_12_7_host" + ], + [ + "+python+pythons_hub", + "python_3_12_8_host", + "+python+python_3_12_8_host" + ], + [ + "+python+pythons_hub", + "python_3_12_host", + "+python+python_3_12_host" + ], + [ + "+python+pythons_hub", + "python_3_13_0_host", + "+python+python_3_13_0_host" + ], + [ + "+python+pythons_hub", + "python_3_13_1_host", + "+python+python_3_13_1_host" + ], + [ + "+python+pythons_hub", + "python_3_13_host", + "+python+python_3_13_host" + ], + [ + "+python+pythons_hub", + "python_3_8_10_host", + "+python+python_3_8_10_host" + ], + [ + "+python+pythons_hub", + "python_3_8_12_host", + "+python+python_3_8_12_host" + ], + [ + "+python+pythons_hub", + "python_3_8_13_host", + "+python+python_3_8_13_host" + ], + [ + "+python+pythons_hub", + "python_3_8_15_host", + "+python+python_3_8_15_host" + ], + [ + "+python+pythons_hub", + "python_3_8_16_host", + "+python+python_3_8_16_host" + ], + [ + "+python+pythons_hub", + "python_3_8_17_host", + "+python+python_3_8_17_host" + ], + [ + "+python+pythons_hub", + "python_3_8_18_host", + "+python+python_3_8_18_host" + ], + [ + "+python+pythons_hub", + "python_3_8_19_host", + "+python+python_3_8_19_host" + ], + [ + "+python+pythons_hub", + "python_3_8_20_host", + "+python+python_3_8_20_host" + ], + [ + "+python+pythons_hub", + "python_3_8_host", + "+python+python_3_8_host" + ], + [ + "+python+pythons_hub", + "python_3_9_10_host", + "+python+python_3_9_10_host" + ], + [ + "+python+pythons_hub", + "python_3_9_12_host", + "+python+python_3_9_12_host" + ], + [ + "+python+pythons_hub", + "python_3_9_13_host", + "+python+python_3_9_13_host" + ], + [ + "+python+pythons_hub", + "python_3_9_15_host", + "+python+python_3_9_15_host" + ], + [ + "+python+pythons_hub", + "python_3_9_16_host", + "+python+python_3_9_16_host" + ], + [ + "+python+pythons_hub", + "python_3_9_17_host", + "+python+python_3_9_17_host" + ], + [ + "+python+pythons_hub", + "python_3_9_18_host", + "+python+python_3_9_18_host" + ], + [ + "+python+pythons_hub", + "python_3_9_19_host", + "+python+python_3_9_19_host" + ], + [ + "+python+pythons_hub", + "python_3_9_20_host", + "+python+python_3_9_20_host" + ], + [ + "+python+pythons_hub", + "python_3_9_21_host", + "+python+python_3_9_21_host" + ], + [ + "+python+pythons_hub", + "python_3_9_host", + "+python+python_3_9_host" + ], + [ + "bazel_features+", + "bazel_features_globals", + "bazel_features++version_extension+bazel_features_globals" + ], + [ + "bazel_features+", + "bazel_features_version", + "bazel_features++version_extension+bazel_features_version" + ] + ] + } + }, + "//python/uv:uv.bzl%uv": { + "general": { + "bzlTransitiveDigest": "DjpJ/IIJl51GG3GQ84gJ20+o2twqsRYNdLHyQJ/OsTQ=", + "usagesDigest": "IBWFhCxATF6PNVT9Z6OyNYwgyK7EktkyRLKaoMPa/yw=", + "recordedFileInputs": {}, + "recordedDirentsInputs": {}, + "envVariables": {}, + "generatedRepoSpecs": { + "uv_darwin_aarch64": { + "repoRuleId": "@@//python/uv/private:uv_repositories.bzl%uv_repository", + "attributes": { + "uv_version": "0.4.25", + "platform": "aarch64-apple-darwin" + } + }, + "uv_linux_aarch64": { + "repoRuleId": "@@//python/uv/private:uv_repositories.bzl%uv_repository", + "attributes": { + "uv_version": "0.4.25", + "platform": "aarch64-unknown-linux-gnu" + } + }, + "uv_linux_ppc": { + "repoRuleId": "@@//python/uv/private:uv_repositories.bzl%uv_repository", + "attributes": { + "uv_version": "0.4.25", + "platform": "powerpc64le-unknown-linux-gnu" + } + }, + "uv_linux_s390x": { + "repoRuleId": "@@//python/uv/private:uv_repositories.bzl%uv_repository", + "attributes": { + "uv_version": "0.4.25", + "platform": "s390x-unknown-linux-gnu" + } + }, + "uv_darwin_x86_64": { + "repoRuleId": "@@//python/uv/private:uv_repositories.bzl%uv_repository", + "attributes": { + "uv_version": "0.4.25", + "platform": "x86_64-apple-darwin" + } + }, + "uv_windows_x86_64": { + "repoRuleId": "@@//python/uv/private:uv_repositories.bzl%uv_repository", + "attributes": { + "uv_version": "0.4.25", + "platform": "x86_64-pc-windows-msvc" + } + }, + "uv_linux_x86_64": { + "repoRuleId": "@@//python/uv/private:uv_repositories.bzl%uv_repository", + "attributes": { + "uv_version": "0.4.25", + "platform": "x86_64-unknown-linux-gnu" + } + }, + "uv_toolchains": { + "repoRuleId": "@@//python/uv/private:uv_toolchains_repo.bzl%uv_toolchains_repo", + "attributes": { + "toolchain_type": "'@@//python/uv:uv_toolchain_type'", + "toolchain_names": [ + "uv_darwin_aarch64_toolchain", + "uv_linux_aarch64_toolchain", + "uv_linux_ppc_toolchain", + "uv_linux_s390x_toolchain", + "uv_darwin_x86_64_toolchain", + "uv_windows_x86_64_toolchain", + "uv_linux_x86_64_toolchain" + ], + "toolchain_labels": { + "uv_darwin_aarch64_toolchain": "@uv_darwin_aarch64//:uv_toolchain", + "uv_linux_aarch64_toolchain": "@uv_linux_aarch64//:uv_toolchain", + "uv_linux_ppc_toolchain": "@uv_linux_ppc//:uv_toolchain", + "uv_linux_s390x_toolchain": "@uv_linux_s390x//:uv_toolchain", + "uv_darwin_x86_64_toolchain": "@uv_darwin_x86_64//:uv_toolchain", + "uv_windows_x86_64_toolchain": "@uv_windows_x86_64//:uv_toolchain", + "uv_linux_x86_64_toolchain": "@uv_linux_x86_64//:uv_toolchain" + }, + "toolchain_compatible_with": { + "uv_darwin_aarch64_toolchain": [ + "@platforms//os:macos", + "@platforms//cpu:aarch64" + ], + "uv_linux_aarch64_toolchain": [ + "@platforms//os:linux", + "@platforms//cpu:aarch64" + ], + "uv_linux_ppc_toolchain": [ + "@platforms//os:linux", + "@platforms//cpu:ppc" + ], + "uv_linux_s390x_toolchain": [ + "@platforms//os:linux", + "@platforms//cpu:s390x" + ], + "uv_darwin_x86_64_toolchain": [ + "@platforms//os:macos", + "@platforms//cpu:x86_64" + ], + "uv_windows_x86_64_toolchain": [ + "@platforms//os:windows", + "@platforms//cpu:x86_64" + ], + "uv_linux_x86_64_toolchain": [ + "@platforms//os:linux", + "@platforms//cpu:x86_64" + ] + } + } + } + }, + "recordedRepoMappingEntries": [] + } + }, + "@@buildifier_prebuilt+//:defs.bzl%buildifier_prebuilt_deps_extension": { + "general": { + "bzlTransitiveDigest": "BQ67MS38sDZxeQEfUs4vghLhs3+m4IXU/i7XC50fl9s=", + "usagesDigest": "JCqhJg+TeFVLBlrKVGI0Npi9RChNqkZQAh9TYfbAobs=", + "recordedFileInputs": {}, + "recordedDirentsInputs": {}, + "envVariables": {}, + "generatedRepoSpecs": { + "buildifier_darwin_amd64": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", + "attributes": { + "urls": [ + "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildifier-darwin-amd64" + ], + "downloaded_file_path": "buildifier", + "executable": true, + "sha256": "e2f4a67691c5f55634fbfb3850eb97dd91be0edd059d947b6c83d120682e0216" + } + }, + "buildifier_darwin_arm64": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", + "attributes": { + "urls": [ + "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildifier-darwin-arm64" + ], + "downloaded_file_path": "buildifier", + "executable": true, + "sha256": "7549b5f535219ac957aa2a6069d46fbfc9ea3f74abd85fd3d460af4b1a2099a6" + } + }, + "buildifier_linux_amd64": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", + "attributes": { + "urls": [ + "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildifier-linux-amd64" + ], + "downloaded_file_path": "buildifier", + "executable": true, + "sha256": "51bc947dabb7b14ec6fb1224464fbcf7a7cb138f1a10a3b328f00835f72852ce" + } + }, + "buildifier_linux_arm64": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", + "attributes": { + "urls": [ + "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildifier-linux-arm64" + ], + "downloaded_file_path": "buildifier", + "executable": true, + "sha256": "0ba6e8e3208b5a029164e542ddb5509e618f87b639ffe8cc2f54770022853080" + } + }, + "buildifier_windows_amd64": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", + "attributes": { + "urls": [ + "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildifier-windows-amd64.exe" + ], + "downloaded_file_path": "buildifier.exe", + "executable": true, + "sha256": "92bdd284fbc6766fc3e300b434ff9e68ac4d76a06cb29d1bdefe79a102a8d135" + } + }, + "buildozer_darwin_amd64": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", + "attributes": { + "urls": [ + "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildozer-darwin-amd64" + ], + "downloaded_file_path": "buildozer", + "executable": true, + "sha256": "4014751a4cc5e91a7dc4b64be7b30c565bd9014ae6d1879818dc624562a1d431" + } + }, + "buildozer_darwin_arm64": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", + "attributes": { + "urls": [ + "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildozer-darwin-arm64" + ], + "downloaded_file_path": "buildozer", + "executable": true, + "sha256": "e78bd5357f2356067d4b0d49ec4e4143dd9b1308746afc6ff11b55b952f462d7" + } + }, + "buildozer_linux_amd64": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", + "attributes": { + "urls": [ + "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildozer-linux-amd64" + ], + "downloaded_file_path": "buildozer", + "executable": true, + "sha256": "2aef0f1ef80a0140b8fe6e6a8eb822e14827d8855bfc6681532c7530339ea23b" + } + }, + "buildozer_linux_arm64": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", + "attributes": { + "urls": [ + "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildozer-linux-arm64" + ], + "downloaded_file_path": "buildozer", + "executable": true, + "sha256": "586e27630cbc242e8bd6fe8e24485eca8dcadea6410cc13cbe059202655980ac" + } + }, + "buildozer_windows_amd64": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", + "attributes": { + "urls": [ + "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildozer-windows-amd64.exe" + ], + "downloaded_file_path": "buildozer.exe", + "executable": true, + "sha256": "07664d5d08ee099f069cd654070cabf2708efaae9f52dc83921fa400c67a868b" + } + }, + "buildifier_prebuilt_toolchains": { + "repoRuleId": "@@buildifier_prebuilt+//:defs.bzl%_buildifier_toolchain_setup", + "attributes": { + "assets_json": "[{\"arch\":\"amd64\",\"name\":\"buildifier\",\"platform\":\"darwin\",\"sha256\":\"e2f4a67691c5f55634fbfb3850eb97dd91be0edd059d947b6c83d120682e0216\",\"version\":\"v6.1.2\"},{\"arch\":\"arm64\",\"name\":\"buildifier\",\"platform\":\"darwin\",\"sha256\":\"7549b5f535219ac957aa2a6069d46fbfc9ea3f74abd85fd3d460af4b1a2099a6\",\"version\":\"v6.1.2\"},{\"arch\":\"amd64\",\"name\":\"buildifier\",\"platform\":\"linux\",\"sha256\":\"51bc947dabb7b14ec6fb1224464fbcf7a7cb138f1a10a3b328f00835f72852ce\",\"version\":\"v6.1.2\"},{\"arch\":\"arm64\",\"name\":\"buildifier\",\"platform\":\"linux\",\"sha256\":\"0ba6e8e3208b5a029164e542ddb5509e618f87b639ffe8cc2f54770022853080\",\"version\":\"v6.1.2\"},{\"arch\":\"amd64\",\"name\":\"buildifier\",\"platform\":\"windows\",\"sha256\":\"92bdd284fbc6766fc3e300b434ff9e68ac4d76a06cb29d1bdefe79a102a8d135\",\"version\":\"v6.1.2\"},{\"arch\":\"amd64\",\"name\":\"buildozer\",\"platform\":\"darwin\",\"sha256\":\"4014751a4cc5e91a7dc4b64be7b30c565bd9014ae6d1879818dc624562a1d431\",\"version\":\"v6.1.2\"},{\"arch\":\"arm64\",\"name\":\"buildozer\",\"platform\":\"darwin\",\"sha256\":\"e78bd5357f2356067d4b0d49ec4e4143dd9b1308746afc6ff11b55b952f462d7\",\"version\":\"v6.1.2\"},{\"arch\":\"amd64\",\"name\":\"buildozer\",\"platform\":\"linux\",\"sha256\":\"2aef0f1ef80a0140b8fe6e6a8eb822e14827d8855bfc6681532c7530339ea23b\",\"version\":\"v6.1.2\"},{\"arch\":\"arm64\",\"name\":\"buildozer\",\"platform\":\"linux\",\"sha256\":\"586e27630cbc242e8bd6fe8e24485eca8dcadea6410cc13cbe059202655980ac\",\"version\":\"v6.1.2\"},{\"arch\":\"amd64\",\"name\":\"buildozer\",\"platform\":\"windows\",\"sha256\":\"07664d5d08ee099f069cd654070cabf2708efaae9f52dc83921fa400c67a868b\",\"version\":\"v6.1.2\"}]" + } + } + }, + "recordedRepoMappingEntries": [ + [ + "buildifier_prebuilt+", + "bazel_skylib", + "bazel_skylib+" + ], + [ + "buildifier_prebuilt+", + "bazel_tools", + "bazel_tools" + ] + ] + } + }, + "@@platforms//host:extension.bzl%host_platform": { + "general": { + "bzlTransitiveDigest": "xelQcPZH8+tmuOHVjL9vDxMnnQNMlwj0SlvgoqBkm4U=", + "usagesDigest": "SeQiIN/f8/Qt9vYQk7qcXp4I4wJeEC0RnQDiaaJ4tb8=", + "recordedFileInputs": {}, + "recordedDirentsInputs": {}, + "envVariables": {}, + "generatedRepoSpecs": { + "host_platform": { + "repoRuleId": "@@platforms//host:extension.bzl%host_platform_repo", + "attributes": {} + } + }, + "recordedRepoMappingEntries": [] + } + }, + "@@rules_java+//java:rules_java_deps.bzl%compatibility_proxy": { + "general": { + "bzlTransitiveDigest": "84xJEZ1jnXXwo8BXMprvBm++rRt4jsTu9liBxz0ivps=", + "usagesDigest": "jTQDdLDxsS43zuRmg1faAjIEPWdLAbDAowI1pInQSoo=", + "recordedFileInputs": {}, + "recordedDirentsInputs": {}, + "envVariables": {}, + "generatedRepoSpecs": { + "compatibility_proxy": { + "repoRuleId": "@@rules_java+//java:rules_java_deps.bzl%_compatibility_proxy_repo_rule", + "attributes": {} + } + }, + "recordedRepoMappingEntries": [ + [ + "rules_java+", + "bazel_tools", + "bazel_tools" + ] + ] + } + }, + "@@rules_kotlin+//src/main/starlark/core/repositories:bzlmod_setup.bzl%rules_kotlin_extensions": { + "general": { + "bzlTransitiveDigest": "sFhcgPbDQehmbD1EOXzX4H1q/CD5df8zwG4kp4jbvr8=", + "usagesDigest": "QI2z8ZUR+mqtbwsf2fLqYdJAkPOHdOV+tF2yVAUgRzw=", + "recordedFileInputs": {}, + "recordedDirentsInputs": {}, + "envVariables": {}, + "generatedRepoSpecs": { + "com_github_jetbrains_kotlin_git": { + "repoRuleId": "@@rules_kotlin+//src/main/starlark/core/repositories:compiler.bzl%kotlin_compiler_git_repository", + "attributes": { + "urls": [ + "https://github.com/JetBrains/kotlin/releases/download/v1.9.23/kotlin-compiler-1.9.23.zip" + ], + "sha256": "93137d3aab9afa9b27cb06a824c2324195c6b6f6179d8a8653f440f5bd58be88" + } + }, + "com_github_jetbrains_kotlin": { + "repoRuleId": "@@rules_kotlin+//src/main/starlark/core/repositories:compiler.bzl%kotlin_capabilities_repository", + "attributes": { + "git_repository_name": "com_github_jetbrains_kotlin_git", + "compiler_version": "1.9.23" + } + }, + "com_github_google_ksp": { + "repoRuleId": "@@rules_kotlin+//src/main/starlark/core/repositories:ksp.bzl%ksp_compiler_plugin_repository", + "attributes": { + "urls": [ + "https://github.com/google/ksp/releases/download/1.9.23-1.0.20/artifacts.zip" + ], + "sha256": "ee0618755913ef7fd6511288a232e8fad24838b9af6ea73972a76e81053c8c2d", + "strip_version": "1.9.23-1.0.20" + } + }, + "com_github_pinterest_ktlint": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", + "attributes": { + "sha256": "01b2e0ef893383a50dbeb13970fe7fa3be36ca3e83259e01649945b09d736985", + "urls": [ + "https://github.com/pinterest/ktlint/releases/download/1.3.0/ktlint" + ], + "executable": true + } + }, + "rules_android": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "sha256": "cd06d15dd8bb59926e4d65f9003bfc20f9da4b2519985c27e190cddc8b7a7806", + "strip_prefix": "rules_android-0.1.1", + "urls": [ + "https://github.com/bazelbuild/rules_android/archive/v0.1.1.zip" + ] + } + } + }, + "recordedRepoMappingEntries": [ + [ + "rules_kotlin+", + "bazel_tools", + "bazel_tools" + ] + ] + } + } + } +} From 05a461254573fd60bb642d3ff04b832976b79e47 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Mon, 24 Feb 2025 00:48:33 +0900 Subject: [PATCH 31/65] Revert "add bzl libs" This reverts commit b4fe6709d41edda0221221323078db5f8c151140. --- python/private/pypi/BUILD.bazel | 31 +------------------------------ 1 file changed, 1 insertion(+), 30 deletions(-) diff --git a/python/private/pypi/BUILD.bazel b/python/private/pypi/BUILD.bazel index 97fb00da7a..6f80272af6 100644 --- a/python/private/pypi/BUILD.bazel +++ b/python/private/pypi/BUILD.bazel @@ -75,9 +75,7 @@ bzl_library( name = "evaluate_markers_bzl", srcs = ["evaluate_markers.bzl"], deps = [ - ":pep508_env_bzl", - ":pep508_evaluate_bzl", - ":pep508_req_bzl", + ":pypi_repo_utils_bzl", ], ) @@ -210,33 +208,6 @@ bzl_library( ], ) -bzl_library( - name = "pep508_evaluate_bzl", - srcs = ["pep508_evaluate.bzl"], - deps = [ - "//python/private:enum_bzl", - "//python/private:semver_bzl", - ], -) - -bzl_library( - name = "pep508_req_bzl", - srcs = ["pep508_req.bzl"], - deps = [ - "//python/private:normalize_name_bzl", - ], -) - -bzl_library( - name = "pep508_env_bzl", - srcs = ["pep508_env.bzl"], - deps = [ - ":pep508_evaluate_bzl", - ":pep508_req_bzl", - "//python/private:normalize_name_bzl", - ], -) - bzl_library( name = "pip_bzl", srcs = ["pip.bzl"], From 1b11c128f4d6235a9bc97ff17179013dfa399045 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Mon, 24 Feb 2025 00:48:34 +0900 Subject: [PATCH 32/65] Revert "cleanup dead code" This reverts commit 58755bdcdaf342fbf4552cfd003817f627a5d980. --- python/private/pypi/evaluate_markers.bzl | 10 +++ .../pypi/requirements_parser/BUILD.bazel | 0 .../resolve_target_platforms.py | 63 +++++++++++++++++++ 3 files changed, 73 insertions(+) create mode 100644 python/private/pypi/requirements_parser/BUILD.bazel create mode 100755 python/private/pypi/requirements_parser/resolve_target_platforms.py diff --git a/python/private/pypi/evaluate_markers.bzl b/python/private/pypi/evaluate_markers.bzl index 1d4c30753f..c2709dbf79 100644 --- a/python/private/pypi/evaluate_markers.bzl +++ b/python/private/pypi/evaluate_markers.bzl @@ -14,10 +14,20 @@ """A simple function that evaluates markers using a python interpreter.""" +load(":deps.bzl", "record_files") load(":pep508_env.bzl", "env", _platform_from_str = "platform_from_str") load(":pep508_evaluate.bzl", "evaluate") load(":pep508_req.bzl", _req = "requirement") +# Used as a default value in a rule to ensure we fetch the dependencies. +SRCS = [ + # When the version, or any of the files in `packaging` package changes, + # this file will change as well. + record_files["pypi__packaging"], + Label("//python/private/pypi/requirements_parser:resolve_target_platforms.py"), + Label("//python/private/pypi/whl_installer:platform.py"), +] + def evaluate_markers(requirements): """Return the list of supported platforms per requirements line. diff --git a/python/private/pypi/requirements_parser/BUILD.bazel b/python/private/pypi/requirements_parser/BUILD.bazel new file mode 100644 index 0000000000..e69de29bb2 diff --git a/python/private/pypi/requirements_parser/resolve_target_platforms.py b/python/private/pypi/requirements_parser/resolve_target_platforms.py new file mode 100755 index 0000000000..c899a943cc --- /dev/null +++ b/python/private/pypi/requirements_parser/resolve_target_platforms.py @@ -0,0 +1,63 @@ +"""A CLI to evaluate env markers for requirements files. + +A simple script to evaluate the `requirements.txt` files. Currently it is only +handling environment markers in the requirements files, but in the future it +may handle more things. We require a `python` interpreter that can run on the +host platform and then we depend on the [packaging] PyPI wheel. + +In order to be able to resolve requirements files for any platform, we are +re-using the same code that is used in the `whl_library` installer. See +[here](../whl_installer/wheel.py). + +Requirements for the code are: +- Depends only on `packaging` and core Python. +- Produces the same result irrespective of the Python interpreter platform or version. + +[packaging]: https://packaging.pypa.io/en/stable/ +""" + +import argparse +import json +import pathlib + +from packaging.requirements import Requirement + +from python.private.pypi.whl_installer.platform import Platform + +INPUT_HELP = """\ +Input path to read the requirements as a json file, the keys in the dictionary +are the requirements lines and the values are strings of target platforms. +""" +OUTPUT_HELP = """\ +Output to write the requirements as a json filepath, the keys in the dictionary +are the requirements lines and the values are strings of target platforms, which +got changed based on the evaluated markers. +""" + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("input_path", type=pathlib.Path, help=INPUT_HELP.strip()) + parser.add_argument("output_path", type=pathlib.Path, help=OUTPUT_HELP.strip()) + args = parser.parse_args() + + with args.input_path.open() as f: + reqs = json.load(f) + + response = {} + for requirement_line, target_platforms in reqs.items(): + entry, prefix, hashes = requirement_line.partition("--hash") + hashes = prefix + hashes + + req = Requirement(entry) + for p in target_platforms: + (platform,) = Platform.from_string(p) + if not req.marker or req.marker.evaluate(platform.env_markers("")): + response.setdefault(requirement_line, []).append(p) + + with args.output_path.open("w") as f: + json.dump(response, f) + + +if __name__ == "__main__": + main() From 301f99f82262fe73d0ff7d61e6ce01f8785f2249 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Mon, 24 Feb 2025 00:48:54 +0900 Subject: [PATCH 33/65] Revert "use starlark to eval markers" This reverts commit 18fe4cc1d8c391a834aed1c0394865b87814a020. --- python/private/pypi/evaluate_markers.bzl | 57 +++++++++++++++++----- python/private/pypi/extension.bzl | 18 ++++++- python/private/pypi/parse_requirements.bzl | 12 ++--- python/private/pypi/pep508_env.bzl | 15 ++---- python/private/pypi/pep508_evaluate.bzl | 2 +- python/private/pypi/pep508_req.bzl | 4 +- python/private/pypi/pip_repository.bzl | 15 +++++- 7 files changed, 84 insertions(+), 39 deletions(-) diff --git a/python/private/pypi/evaluate_markers.bzl b/python/private/pypi/evaluate_markers.bzl index c2709dbf79..ec5f576945 100644 --- a/python/private/pypi/evaluate_markers.bzl +++ b/python/private/pypi/evaluate_markers.bzl @@ -15,9 +15,7 @@ """A simple function that evaluates markers using a python interpreter.""" load(":deps.bzl", "record_files") -load(":pep508_env.bzl", "env", _platform_from_str = "platform_from_str") -load(":pep508_evaluate.bzl", "evaluate") -load(":pep508_req.bzl", _req = "requirement") +load(":pypi_repo_utils.bzl", "pypi_repo_utils") # Used as a default value in a rule to ensure we fetch the dependencies. SRCS = [ @@ -28,20 +26,53 @@ SRCS = [ Label("//python/private/pypi/whl_installer:platform.py"), ] -def evaluate_markers(requirements): +def evaluate_markers(mrctx, *, requirements, python_interpreter, python_interpreter_target, srcs, logger = None): """Return the list of supported platforms per requirements line. Args: - requirements: dict[str, list[str]] of the requirement file lines to evaluate. + mrctx: repository_ctx or module_ctx. + requirements: list[str] of the requirement file lines to evaluate. + python_interpreter: str, path to the python_interpreter to use to + evaluate the env markers in the given requirements files. It will + be only called if the requirements files have env markers. This + should be something that is in your PATH or an absolute path. + python_interpreter_target: Label, same as python_interpreter, but in a + label format. + srcs: list[Label], the value of SRCS passed from the `rctx` or `mctx` to this function. + logger: repo_utils.logger or None, a simple struct to log diagnostic + messages. Defaults to None. Returns: dict of string lists with target platforms """ - ret = {} - for req_string, platforms in requirements.items(): - req = _req(req_string) - for platform in platforms: - if evaluate(req.marker, env = env(_platform_from_str(platform, None))): - ret.setdefault(req_string, []).append(platform) - - return ret + if not requirements: + return {} + + in_file = mrctx.path("requirements_with_markers.in.json") + out_file = mrctx.path("requirements_with_markers.out.json") + mrctx.file(in_file, json.encode(requirements)) + + pypi_repo_utils.execute_checked( + mrctx, + op = "ResolveRequirementEnvMarkers({})".format(in_file), + arguments = [ + pypi_repo_utils.resolve_python_interpreter( + mrctx, + python_interpreter = python_interpreter, + python_interpreter_target = python_interpreter_target, + ), + "-m", + "python.private.pypi.requirements_parser.resolve_target_platforms", + in_file, + out_file, + ], + srcs = srcs, + environment = { + "PYTHONPATH": [ + Label("@pypi__packaging//:BUILD.bazel"), + Label("//:BUILD.bazel"), + ], + }, + logger = logger, + ) + return json.decode(mrctx.read(out_file)) diff --git a/python/private/pypi/extension.bzl b/python/private/pypi/extension.bzl index 92d1d50937..405c22f60e 100644 --- a/python/private/pypi/extension.bzl +++ b/python/private/pypi/extension.bzl @@ -22,7 +22,7 @@ load("//python/private:repo_utils.bzl", "repo_utils") load("//python/private:semver.bzl", "semver") load("//python/private:version_label.bzl", "version_label") load(":attrs.bzl", "use_isolated") -load(":evaluate_markers.bzl", "evaluate_markers") +load(":evaluate_markers.bzl", "evaluate_markers", EVALUATE_MARKERS_SRCS = "SRCS") load(":hub_repository.bzl", "hub_repository", "whl_config_settings_to_json") load(":parse_requirements.bzl", "parse_requirements") load(":parse_whl_name.bzl", "parse_whl_name") @@ -180,7 +180,14 @@ def _create_whl_repos( # instances to perform this manipulation. This function should be executed # only once by the underlying code to minimize the overhead needed to # spin up a Python interpreter. - evaluate_markers = lambda r: evaluate_markers(r), + evaluate_markers = lambda module_ctx, requirements: evaluate_markers( + module_ctx, + requirements = requirements, + python_interpreter = pip_attr.python_interpreter, + python_interpreter_target = python_interpreter_target, + srcs = pip_attr._evaluate_markers_srcs, + logger = logger, + ), logger = logger, ) @@ -752,6 +759,13 @@ a corresponding `python.toolchain()` configured. doc = """\ A dict of labels to wheel names that is typically generated by the whl_modifications. The labels are JSON config files describing the modifications. +""", + ), + "_evaluate_markers_srcs": attr.label_list( + default = EVALUATE_MARKERS_SRCS, + doc = """\ +The list of labels to use as SRCS for the marker evaluation code. This ensures that the +code will be re-evaluated when any of files in the default changes. """, ), }, **ATTRS) diff --git a/python/private/pypi/parse_requirements.bzl b/python/private/pypi/parse_requirements.bzl index f36a97eb26..2bca8d8621 100644 --- a/python/private/pypi/parse_requirements.bzl +++ b/python/private/pypi/parse_requirements.bzl @@ -67,10 +67,10 @@ def parse_requirements( of the distribution URLs from a PyPI index. Accepts ctx and distribution names to query. evaluate_markers: A function to use to evaluate the requirements. - Accepts a dict where keys are requirement lines to evaluate against - the platforms stored as values in the input dict. Returns the same - dict, but with values being platforms that are compatible with the - requirements line. + Accepts the ctx and a dict where keys are requirement lines to + evaluate against the platforms stored as values in the input dict. + Returns the same dict, but with values being platforms that are + compatible with the requirements line. logger: repo_utils.logger or None, a simple struct to log diagnostic messages. Returns: @@ -93,7 +93,7 @@ def parse_requirements( The second element is extra_pip_args should be passed to `whl_library`. """ - evaluate_markers = evaluate_markers or (lambda _: {}) + evaluate_markers = evaluate_markers or (lambda *_: {}) options = {} requirements = {} for file, plats in requirements_by_platform.items(): @@ -168,7 +168,7 @@ def parse_requirements( # to do, we could use Python to parse the requirement lines and infer the # URL of the files to download things from. This should be important for # VCS package references. - env_marker_target_platforms = evaluate_markers(reqs_with_env_markers) + env_marker_target_platforms = evaluate_markers(ctx, reqs_with_env_markers) if logger: logger.debug(lambda: "Evaluated env markers from:\n{}\n\nTo:\n{}".format( reqs_with_env_markers, diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 2629051af1..542771dfa9 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -114,10 +114,10 @@ def deps(name, *, requires_dist, platforms = [], extras = [], host_python_versio reqs = [r for r in reqs if r.name != name] platforms = [ - platform_from_str(p, python_version = host_python_version) + _platform_from_str(p, python_version = host_python_version) for p in platforms ] or [ - platform_from_str("", python_version = host_python_version), + _platform_from_str("", python_version = host_python_version), ] abis = sorted({p.abi: True for p in platforms if p.abi}) @@ -157,16 +157,7 @@ def _platform(*, abi = None, os = None, arch = None): arch = arch, ) -def platform_from_str(p, python_version): - """Return a platform from a string. - - Args: - p: {type}`str` the actual string. - python_version: {type}`str` the python version to add to platform if needed. - - Returns: - A struct that is returned by the `_platform` function. - """ +def _platform_from_str(p, python_version): if p.startswith("cp"): abi, _, p = p.partition("_") elif python_version: diff --git a/python/private/pypi/pep508_evaluate.bzl b/python/private/pypi/pep508_evaluate.bzl index a5082df95e..6703b3fcd0 100644 --- a/python/private/pypi/pep508_evaluate.bzl +++ b/python/private/pypi/pep508_evaluate.bzl @@ -114,7 +114,7 @@ def tokenize(marker): elif char in _WSP: state = _STATE.NONE else: - fail("BUG: Cannot parse '{}' in {} ({})".format(char, state, marker)) + fail("BUG: Cannot parse '{}' in {}".format(char, state)) else: token += char diff --git a/python/private/pypi/pep508_req.bzl b/python/private/pypi/pep508_req.bzl index 43159b3ed8..fbb54adee1 100644 --- a/python/private/pypi/pep508_req.bzl +++ b/python/private/pypi/pep508_req.bzl @@ -26,13 +26,11 @@ def requirement(spec): Returns: A struct with the information. """ - requires, _, maybe_hashes = spec.partition(";") - marker, _, _ = maybe_hashes.partition("--hash") + requires, _, marker = spec.partition(";") requires, _, extras_unparsed = requires.partition("[") requires, _, _ = requires.partition("(") requires, _, _ = requires.partition(" ") extras = extras_unparsed.strip("]").split(",") - return struct( name = normalize_name(requires.strip(" ")), marker = marker.strip(" "), diff --git a/python/private/pypi/pip_repository.bzl b/python/private/pypi/pip_repository.bzl index 7f0ea9827a..029566eea3 100644 --- a/python/private/pypi/pip_repository.bzl +++ b/python/private/pypi/pip_repository.bzl @@ -18,7 +18,7 @@ load("@bazel_skylib//lib:sets.bzl", "sets") load("//python/private:normalize_name.bzl", "normalize_name") load("//python/private:repo_utils.bzl", "REPO_DEBUG_ENV_VAR") load("//python/private:text_util.bzl", "render") -load(":evaluate_markers.bzl", "evaluate_markers") +load(":evaluate_markers.bzl", "evaluate_markers", EVALUATE_MARKERS_SRCS = "SRCS") load(":parse_requirements.bzl", "host_platform", "parse_requirements", "select_requirement") load(":pip_repository_attrs.bzl", "ATTRS") load(":render_pkg_aliases.bzl", "render_pkg_aliases") @@ -82,8 +82,12 @@ def _pip_repository_impl(rctx): extra_pip_args = rctx.attr.extra_pip_args, ), extra_pip_args = rctx.attr.extra_pip_args, - evaluate_markers = lambda requirements: evaluate_markers( + evaluate_markers = lambda rctx, requirements: evaluate_markers( + rctx, requirements = requirements, + python_interpreter = rctx.attr.python_interpreter, + python_interpreter_target = rctx.attr.python_interpreter_target, + srcs = rctx.attr._evaluate_markers_srcs, ), ) selected_requirements = {} @@ -230,6 +234,13 @@ file](https://github.com/bazelbuild/rules_python/blob/main/examples/pip_reposito _template = attr.label( default = ":requirements.bzl.tmpl.workspace", ), + _evaluate_markers_srcs = attr.label_list( + default = EVALUATE_MARKERS_SRCS, + doc = """\ +The list of labels to use as SRCS for the marker evaluation code. This ensures that the +code will be re-evaluated when any of files in the default changes. +""", + ), **ATTRS ), doc = """Accepts a locked/compiled requirements file and installs the dependencies listed within. From 49433ba5fe0b9f1acd5d673f6154bb7741453bf4 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Mon, 24 Feb 2025 00:49:20 +0900 Subject: [PATCH 34/65] wip --- MODULE.bazel.lock | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/MODULE.bazel.lock b/MODULE.bazel.lock index 4b701a6c13..f869e2ba2c 100644 --- a/MODULE.bazel.lock +++ b/MODULE.bazel.lock @@ -157,11 +157,14 @@ "moduleExtensions": { "//python/extensions:pip.bzl%pip": { "general": { - "bzlTransitiveDigest": "wLC8ZJWm/oKERWSJ53dCg6RKNEOh6HUrDJ9CAzOwVYs=", + "bzlTransitiveDigest": "wD8fCODri59Zu7DiWPR4hDvyTO6z2gOwRENJFywXO0Q=", "usagesDigest": "YlSFe2ItKSPNZPX8lwGeHExgU3q/r1fVYnFieVD4qmQ=", "recordedFileInputs": { + "@@+internal_deps+pypi__packaging//packaging-24.0.dist-info/RECORD": "be1aea790359b4c2c9ea83d153c1a57c407742a35b95ee36d00723509f5ed5dd", "@@//docs/requirements.txt": "4b7f6f5e699049343db70f8bda0c2b97be9fd9b1b3c117a2b624dc633ba944a5", "@@//examples/wheel/requirements_server.txt": "981e09e454aa31d72f73f369436fce488e5a478717a8fac808412f4695e44823", + "@@//python/private/pypi/requirements_parser/resolve_target_platforms.py": "42bf51980528302373529bcdfddb8014e485182d6bc9d2f7d3bbe1f11d8d923d", + "@@//python/private/pypi/whl_installer/platform.py": "b944b908b25a2f97d6d9f491504ad5d2507402d7e37c802ee878783f87f2aa11", "@@//tools/publish/requirements_darwin.txt": "095d4a4f3d639dce831cd493367631cd51b53665292ab20194bac2c0c6458fa8", "@@//tools/publish/requirements_linux.txt": "d576e0d8542df61396a9b38deeaa183c24135ed5e8e73bb9622f298f2671811e", "@@//tools/publish/requirements_windows.txt": "d18538a3982beab378fd5687f4db33162ee1ece69801f9a451661b1b64286b76", From 458cb456dcf3aca67ccc6b11dec80dbcb4bae1fe Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Mon, 24 Feb 2025 00:49:36 +0900 Subject: [PATCH 35/65] Reapply "use starlark to eval markers" This reverts commit 301f99f82262fe73d0ff7d61e6ce01f8785f2249. --- python/private/pypi/evaluate_markers.bzl | 57 +++++----------------- python/private/pypi/extension.bzl | 18 +------ python/private/pypi/parse_requirements.bzl | 12 ++--- python/private/pypi/pep508_env.bzl | 15 ++++-- python/private/pypi/pep508_evaluate.bzl | 2 +- python/private/pypi/pep508_req.bzl | 4 +- python/private/pypi/pip_repository.bzl | 15 +----- 7 files changed, 39 insertions(+), 84 deletions(-) diff --git a/python/private/pypi/evaluate_markers.bzl b/python/private/pypi/evaluate_markers.bzl index ec5f576945..c2709dbf79 100644 --- a/python/private/pypi/evaluate_markers.bzl +++ b/python/private/pypi/evaluate_markers.bzl @@ -15,7 +15,9 @@ """A simple function that evaluates markers using a python interpreter.""" load(":deps.bzl", "record_files") -load(":pypi_repo_utils.bzl", "pypi_repo_utils") +load(":pep508_env.bzl", "env", _platform_from_str = "platform_from_str") +load(":pep508_evaluate.bzl", "evaluate") +load(":pep508_req.bzl", _req = "requirement") # Used as a default value in a rule to ensure we fetch the dependencies. SRCS = [ @@ -26,53 +28,20 @@ SRCS = [ Label("//python/private/pypi/whl_installer:platform.py"), ] -def evaluate_markers(mrctx, *, requirements, python_interpreter, python_interpreter_target, srcs, logger = None): +def evaluate_markers(requirements): """Return the list of supported platforms per requirements line. Args: - mrctx: repository_ctx or module_ctx. - requirements: list[str] of the requirement file lines to evaluate. - python_interpreter: str, path to the python_interpreter to use to - evaluate the env markers in the given requirements files. It will - be only called if the requirements files have env markers. This - should be something that is in your PATH or an absolute path. - python_interpreter_target: Label, same as python_interpreter, but in a - label format. - srcs: list[Label], the value of SRCS passed from the `rctx` or `mctx` to this function. - logger: repo_utils.logger or None, a simple struct to log diagnostic - messages. Defaults to None. + requirements: dict[str, list[str]] of the requirement file lines to evaluate. Returns: dict of string lists with target platforms """ - if not requirements: - return {} - - in_file = mrctx.path("requirements_with_markers.in.json") - out_file = mrctx.path("requirements_with_markers.out.json") - mrctx.file(in_file, json.encode(requirements)) - - pypi_repo_utils.execute_checked( - mrctx, - op = "ResolveRequirementEnvMarkers({})".format(in_file), - arguments = [ - pypi_repo_utils.resolve_python_interpreter( - mrctx, - python_interpreter = python_interpreter, - python_interpreter_target = python_interpreter_target, - ), - "-m", - "python.private.pypi.requirements_parser.resolve_target_platforms", - in_file, - out_file, - ], - srcs = srcs, - environment = { - "PYTHONPATH": [ - Label("@pypi__packaging//:BUILD.bazel"), - Label("//:BUILD.bazel"), - ], - }, - logger = logger, - ) - return json.decode(mrctx.read(out_file)) + ret = {} + for req_string, platforms in requirements.items(): + req = _req(req_string) + for platform in platforms: + if evaluate(req.marker, env = env(_platform_from_str(platform, None))): + ret.setdefault(req_string, []).append(platform) + + return ret diff --git a/python/private/pypi/extension.bzl b/python/private/pypi/extension.bzl index 405c22f60e..92d1d50937 100644 --- a/python/private/pypi/extension.bzl +++ b/python/private/pypi/extension.bzl @@ -22,7 +22,7 @@ load("//python/private:repo_utils.bzl", "repo_utils") load("//python/private:semver.bzl", "semver") load("//python/private:version_label.bzl", "version_label") load(":attrs.bzl", "use_isolated") -load(":evaluate_markers.bzl", "evaluate_markers", EVALUATE_MARKERS_SRCS = "SRCS") +load(":evaluate_markers.bzl", "evaluate_markers") load(":hub_repository.bzl", "hub_repository", "whl_config_settings_to_json") load(":parse_requirements.bzl", "parse_requirements") load(":parse_whl_name.bzl", "parse_whl_name") @@ -180,14 +180,7 @@ def _create_whl_repos( # instances to perform this manipulation. This function should be executed # only once by the underlying code to minimize the overhead needed to # spin up a Python interpreter. - evaluate_markers = lambda module_ctx, requirements: evaluate_markers( - module_ctx, - requirements = requirements, - python_interpreter = pip_attr.python_interpreter, - python_interpreter_target = python_interpreter_target, - srcs = pip_attr._evaluate_markers_srcs, - logger = logger, - ), + evaluate_markers = lambda r: evaluate_markers(r), logger = logger, ) @@ -759,13 +752,6 @@ a corresponding `python.toolchain()` configured. doc = """\ A dict of labels to wheel names that is typically generated by the whl_modifications. The labels are JSON config files describing the modifications. -""", - ), - "_evaluate_markers_srcs": attr.label_list( - default = EVALUATE_MARKERS_SRCS, - doc = """\ -The list of labels to use as SRCS for the marker evaluation code. This ensures that the -code will be re-evaluated when any of files in the default changes. """, ), }, **ATTRS) diff --git a/python/private/pypi/parse_requirements.bzl b/python/private/pypi/parse_requirements.bzl index 2bca8d8621..f36a97eb26 100644 --- a/python/private/pypi/parse_requirements.bzl +++ b/python/private/pypi/parse_requirements.bzl @@ -67,10 +67,10 @@ def parse_requirements( of the distribution URLs from a PyPI index. Accepts ctx and distribution names to query. evaluate_markers: A function to use to evaluate the requirements. - Accepts the ctx and a dict where keys are requirement lines to - evaluate against the platforms stored as values in the input dict. - Returns the same dict, but with values being platforms that are - compatible with the requirements line. + Accepts a dict where keys are requirement lines to evaluate against + the platforms stored as values in the input dict. Returns the same + dict, but with values being platforms that are compatible with the + requirements line. logger: repo_utils.logger or None, a simple struct to log diagnostic messages. Returns: @@ -93,7 +93,7 @@ def parse_requirements( The second element is extra_pip_args should be passed to `whl_library`. """ - evaluate_markers = evaluate_markers or (lambda *_: {}) + evaluate_markers = evaluate_markers or (lambda _: {}) options = {} requirements = {} for file, plats in requirements_by_platform.items(): @@ -168,7 +168,7 @@ def parse_requirements( # to do, we could use Python to parse the requirement lines and infer the # URL of the files to download things from. This should be important for # VCS package references. - env_marker_target_platforms = evaluate_markers(ctx, reqs_with_env_markers) + env_marker_target_platforms = evaluate_markers(reqs_with_env_markers) if logger: logger.debug(lambda: "Evaluated env markers from:\n{}\n\nTo:\n{}".format( reqs_with_env_markers, diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 542771dfa9..2629051af1 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -114,10 +114,10 @@ def deps(name, *, requires_dist, platforms = [], extras = [], host_python_versio reqs = [r for r in reqs if r.name != name] platforms = [ - _platform_from_str(p, python_version = host_python_version) + platform_from_str(p, python_version = host_python_version) for p in platforms ] or [ - _platform_from_str("", python_version = host_python_version), + platform_from_str("", python_version = host_python_version), ] abis = sorted({p.abi: True for p in platforms if p.abi}) @@ -157,7 +157,16 @@ def _platform(*, abi = None, os = None, arch = None): arch = arch, ) -def _platform_from_str(p, python_version): +def platform_from_str(p, python_version): + """Return a platform from a string. + + Args: + p: {type}`str` the actual string. + python_version: {type}`str` the python version to add to platform if needed. + + Returns: + A struct that is returned by the `_platform` function. + """ if p.startswith("cp"): abi, _, p = p.partition("_") elif python_version: diff --git a/python/private/pypi/pep508_evaluate.bzl b/python/private/pypi/pep508_evaluate.bzl index 6703b3fcd0..a5082df95e 100644 --- a/python/private/pypi/pep508_evaluate.bzl +++ b/python/private/pypi/pep508_evaluate.bzl @@ -114,7 +114,7 @@ def tokenize(marker): elif char in _WSP: state = _STATE.NONE else: - fail("BUG: Cannot parse '{}' in {}".format(char, state)) + fail("BUG: Cannot parse '{}' in {} ({})".format(char, state, marker)) else: token += char diff --git a/python/private/pypi/pep508_req.bzl b/python/private/pypi/pep508_req.bzl index fbb54adee1..43159b3ed8 100644 --- a/python/private/pypi/pep508_req.bzl +++ b/python/private/pypi/pep508_req.bzl @@ -26,11 +26,13 @@ def requirement(spec): Returns: A struct with the information. """ - requires, _, marker = spec.partition(";") + requires, _, maybe_hashes = spec.partition(";") + marker, _, _ = maybe_hashes.partition("--hash") requires, _, extras_unparsed = requires.partition("[") requires, _, _ = requires.partition("(") requires, _, _ = requires.partition(" ") extras = extras_unparsed.strip("]").split(",") + return struct( name = normalize_name(requires.strip(" ")), marker = marker.strip(" "), diff --git a/python/private/pypi/pip_repository.bzl b/python/private/pypi/pip_repository.bzl index 029566eea3..7f0ea9827a 100644 --- a/python/private/pypi/pip_repository.bzl +++ b/python/private/pypi/pip_repository.bzl @@ -18,7 +18,7 @@ load("@bazel_skylib//lib:sets.bzl", "sets") load("//python/private:normalize_name.bzl", "normalize_name") load("//python/private:repo_utils.bzl", "REPO_DEBUG_ENV_VAR") load("//python/private:text_util.bzl", "render") -load(":evaluate_markers.bzl", "evaluate_markers", EVALUATE_MARKERS_SRCS = "SRCS") +load(":evaluate_markers.bzl", "evaluate_markers") load(":parse_requirements.bzl", "host_platform", "parse_requirements", "select_requirement") load(":pip_repository_attrs.bzl", "ATTRS") load(":render_pkg_aliases.bzl", "render_pkg_aliases") @@ -82,12 +82,8 @@ def _pip_repository_impl(rctx): extra_pip_args = rctx.attr.extra_pip_args, ), extra_pip_args = rctx.attr.extra_pip_args, - evaluate_markers = lambda rctx, requirements: evaluate_markers( - rctx, + evaluate_markers = lambda requirements: evaluate_markers( requirements = requirements, - python_interpreter = rctx.attr.python_interpreter, - python_interpreter_target = rctx.attr.python_interpreter_target, - srcs = rctx.attr._evaluate_markers_srcs, ), ) selected_requirements = {} @@ -234,13 +230,6 @@ file](https://github.com/bazelbuild/rules_python/blob/main/examples/pip_reposito _template = attr.label( default = ":requirements.bzl.tmpl.workspace", ), - _evaluate_markers_srcs = attr.label_list( - default = EVALUATE_MARKERS_SRCS, - doc = """\ -The list of labels to use as SRCS for the marker evaluation code. This ensures that the -code will be re-evaluated when any of files in the default changes. -""", - ), **ATTRS ), doc = """Accepts a locked/compiled requirements file and installs the dependencies listed within. From 226344fb2662edfd5dbcd9680490e35b9b518943 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Mon, 24 Feb 2025 00:49:38 +0900 Subject: [PATCH 36/65] Reapply "cleanup dead code" This reverts commit 1b11c128f4d6235a9bc97ff17179013dfa399045. --- python/private/pypi/evaluate_markers.bzl | 10 --- .../pypi/requirements_parser/BUILD.bazel | 0 .../resolve_target_platforms.py | 63 ------------------- 3 files changed, 73 deletions(-) delete mode 100644 python/private/pypi/requirements_parser/BUILD.bazel delete mode 100755 python/private/pypi/requirements_parser/resolve_target_platforms.py diff --git a/python/private/pypi/evaluate_markers.bzl b/python/private/pypi/evaluate_markers.bzl index c2709dbf79..1d4c30753f 100644 --- a/python/private/pypi/evaluate_markers.bzl +++ b/python/private/pypi/evaluate_markers.bzl @@ -14,20 +14,10 @@ """A simple function that evaluates markers using a python interpreter.""" -load(":deps.bzl", "record_files") load(":pep508_env.bzl", "env", _platform_from_str = "platform_from_str") load(":pep508_evaluate.bzl", "evaluate") load(":pep508_req.bzl", _req = "requirement") -# Used as a default value in a rule to ensure we fetch the dependencies. -SRCS = [ - # When the version, or any of the files in `packaging` package changes, - # this file will change as well. - record_files["pypi__packaging"], - Label("//python/private/pypi/requirements_parser:resolve_target_platforms.py"), - Label("//python/private/pypi/whl_installer:platform.py"), -] - def evaluate_markers(requirements): """Return the list of supported platforms per requirements line. diff --git a/python/private/pypi/requirements_parser/BUILD.bazel b/python/private/pypi/requirements_parser/BUILD.bazel deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/python/private/pypi/requirements_parser/resolve_target_platforms.py b/python/private/pypi/requirements_parser/resolve_target_platforms.py deleted file mode 100755 index c899a943cc..0000000000 --- a/python/private/pypi/requirements_parser/resolve_target_platforms.py +++ /dev/null @@ -1,63 +0,0 @@ -"""A CLI to evaluate env markers for requirements files. - -A simple script to evaluate the `requirements.txt` files. Currently it is only -handling environment markers in the requirements files, but in the future it -may handle more things. We require a `python` interpreter that can run on the -host platform and then we depend on the [packaging] PyPI wheel. - -In order to be able to resolve requirements files for any platform, we are -re-using the same code that is used in the `whl_library` installer. See -[here](../whl_installer/wheel.py). - -Requirements for the code are: -- Depends only on `packaging` and core Python. -- Produces the same result irrespective of the Python interpreter platform or version. - -[packaging]: https://packaging.pypa.io/en/stable/ -""" - -import argparse -import json -import pathlib - -from packaging.requirements import Requirement - -from python.private.pypi.whl_installer.platform import Platform - -INPUT_HELP = """\ -Input path to read the requirements as a json file, the keys in the dictionary -are the requirements lines and the values are strings of target platforms. -""" -OUTPUT_HELP = """\ -Output to write the requirements as a json filepath, the keys in the dictionary -are the requirements lines and the values are strings of target platforms, which -got changed based on the evaluated markers. -""" - - -def main(): - parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument("input_path", type=pathlib.Path, help=INPUT_HELP.strip()) - parser.add_argument("output_path", type=pathlib.Path, help=OUTPUT_HELP.strip()) - args = parser.parse_args() - - with args.input_path.open() as f: - reqs = json.load(f) - - response = {} - for requirement_line, target_platforms in reqs.items(): - entry, prefix, hashes = requirement_line.partition("--hash") - hashes = prefix + hashes - - req = Requirement(entry) - for p in target_platforms: - (platform,) = Platform.from_string(p) - if not req.marker or req.marker.evaluate(platform.env_markers("")): - response.setdefault(requirement_line, []).append(p) - - with args.output_path.open("w") as f: - json.dump(response, f) - - -if __name__ == "__main__": - main() From f68475950e403d806ee0c688289fe82ed4ce2c7f Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Mon, 24 Feb 2025 00:49:39 +0900 Subject: [PATCH 37/65] Reapply "add bzl libs" This reverts commit 05a461254573fd60bb642d3ff04b832976b79e47. --- python/private/pypi/BUILD.bazel | 31 ++++++++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/python/private/pypi/BUILD.bazel b/python/private/pypi/BUILD.bazel index 6f80272af6..97fb00da7a 100644 --- a/python/private/pypi/BUILD.bazel +++ b/python/private/pypi/BUILD.bazel @@ -75,7 +75,9 @@ bzl_library( name = "evaluate_markers_bzl", srcs = ["evaluate_markers.bzl"], deps = [ - ":pypi_repo_utils_bzl", + ":pep508_env_bzl", + ":pep508_evaluate_bzl", + ":pep508_req_bzl", ], ) @@ -208,6 +210,33 @@ bzl_library( ], ) +bzl_library( + name = "pep508_evaluate_bzl", + srcs = ["pep508_evaluate.bzl"], + deps = [ + "//python/private:enum_bzl", + "//python/private:semver_bzl", + ], +) + +bzl_library( + name = "pep508_req_bzl", + srcs = ["pep508_req.bzl"], + deps = [ + "//python/private:normalize_name_bzl", + ], +) + +bzl_library( + name = "pep508_env_bzl", + srcs = ["pep508_env.bzl"], + deps = [ + ":pep508_evaluate_bzl", + ":pep508_req_bzl", + "//python/private:normalize_name_bzl", + ], +) + bzl_library( name = "pip_bzl", srcs = ["pip.bzl"], From fe5d7fc9729612ea2af8f3b27ebf178f2f57bcff Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Mon, 24 Feb 2025 00:50:10 +0900 Subject: [PATCH 38/65] no python usage for req parsing --- MODULE.bazel.lock | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/MODULE.bazel.lock b/MODULE.bazel.lock index f869e2ba2c..4b701a6c13 100644 --- a/MODULE.bazel.lock +++ b/MODULE.bazel.lock @@ -157,14 +157,11 @@ "moduleExtensions": { "//python/extensions:pip.bzl%pip": { "general": { - "bzlTransitiveDigest": "wD8fCODri59Zu7DiWPR4hDvyTO6z2gOwRENJFywXO0Q=", + "bzlTransitiveDigest": "wLC8ZJWm/oKERWSJ53dCg6RKNEOh6HUrDJ9CAzOwVYs=", "usagesDigest": "YlSFe2ItKSPNZPX8lwGeHExgU3q/r1fVYnFieVD4qmQ=", "recordedFileInputs": { - "@@+internal_deps+pypi__packaging//packaging-24.0.dist-info/RECORD": "be1aea790359b4c2c9ea83d153c1a57c407742a35b95ee36d00723509f5ed5dd", "@@//docs/requirements.txt": "4b7f6f5e699049343db70f8bda0c2b97be9fd9b1b3c117a2b624dc633ba944a5", "@@//examples/wheel/requirements_server.txt": "981e09e454aa31d72f73f369436fce488e5a478717a8fac808412f4695e44823", - "@@//python/private/pypi/requirements_parser/resolve_target_platforms.py": "42bf51980528302373529bcdfddb8014e485182d6bc9d2f7d3bbe1f11d8d923d", - "@@//python/private/pypi/whl_installer/platform.py": "b944b908b25a2f97d6d9f491504ad5d2507402d7e37c802ee878783f87f2aa11", "@@//tools/publish/requirements_darwin.txt": "095d4a4f3d639dce831cd493367631cd51b53665292ab20194bac2c0c6458fa8", "@@//tools/publish/requirements_linux.txt": "d576e0d8542df61396a9b38deeaa183c24135ed5e8e73bb9622f298f2671811e", "@@//tools/publish/requirements_windows.txt": "d18538a3982beab378fd5687f4db33162ee1ece69801f9a451661b1b64286b76", From ca2527e3507dfb164ce638f53ab10b65ba5a8cba Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Mon, 24 Feb 2025 01:14:50 +0900 Subject: [PATCH 39/65] fully move the parsing of Requires-Dist to starlark --- MODULE.bazel.lock | 2 +- python/private/pypi/pep508_req.bzl | 6 +- python/private/pypi/whl_installer/BUILD.bazel | 1 - .../private/pypi/whl_installer/arguments.py | 8 - python/private/pypi/whl_installer/platform.py | 302 ------------------ python/private/pypi/whl_installer/wheel.py | 282 ---------------- .../pypi/whl_installer/wheel_installer.py | 38 +-- python/private/pypi/whl_library.bzl | 20 +- 8 files changed, 41 insertions(+), 618 deletions(-) delete mode 100644 python/private/pypi/whl_installer/platform.py diff --git a/MODULE.bazel.lock b/MODULE.bazel.lock index 4b701a6c13..9a284d90a3 100644 --- a/MODULE.bazel.lock +++ b/MODULE.bazel.lock @@ -157,7 +157,7 @@ "moduleExtensions": { "//python/extensions:pip.bzl%pip": { "general": { - "bzlTransitiveDigest": "wLC8ZJWm/oKERWSJ53dCg6RKNEOh6HUrDJ9CAzOwVYs=", + "bzlTransitiveDigest": "1N+DRsUmU5BVyzMyxa/+9ITJ8X7fWEnWTCnW4LOMmpg=", "usagesDigest": "YlSFe2ItKSPNZPX8lwGeHExgU3q/r1fVYnFieVD4qmQ=", "recordedFileInputs": { "@@//docs/requirements.txt": "4b7f6f5e699049343db70f8bda0c2b97be9fd9b1b3c117a2b624dc633ba944a5", diff --git a/python/private/pypi/pep508_req.bzl b/python/private/pypi/pep508_req.bzl index 43159b3ed8..618ffaf17a 100644 --- a/python/private/pypi/pep508_req.bzl +++ b/python/private/pypi/pep508_req.bzl @@ -17,6 +17,8 @@ load("//python/private:normalize_name.bzl", "normalize_name") +_STRIP = ["(", " ", ">", "=", "<", "~", "!"] + def requirement(spec): """Parse a PEP508 requirement line @@ -29,8 +31,8 @@ def requirement(spec): requires, _, maybe_hashes = spec.partition(";") marker, _, _ = maybe_hashes.partition("--hash") requires, _, extras_unparsed = requires.partition("[") - requires, _, _ = requires.partition("(") - requires, _, _ = requires.partition(" ") + for char in _STRIP: + requires, _, _ = requires.partition(char) extras = extras_unparsed.strip("]").split(",") return struct( diff --git a/python/private/pypi/whl_installer/BUILD.bazel b/python/private/pypi/whl_installer/BUILD.bazel index 5fb617004d..49f1a119c1 100644 --- a/python/private/pypi/whl_installer/BUILD.bazel +++ b/python/private/pypi/whl_installer/BUILD.bazel @@ -6,7 +6,6 @@ py_library( srcs = [ "arguments.py", "namespace_pkgs.py", - "platform.py", "wheel.py", "wheel_installer.py", ], diff --git a/python/private/pypi/whl_installer/arguments.py b/python/private/pypi/whl_installer/arguments.py index 29bea8026e..bb841ea9ab 100644 --- a/python/private/pypi/whl_installer/arguments.py +++ b/python/private/pypi/whl_installer/arguments.py @@ -17,8 +17,6 @@ import pathlib from typing import Any, Dict, Set -from python.private.pypi.whl_installer.platform import Platform - def parser(**kwargs: Any) -> argparse.ArgumentParser: """Create a parser for the wheel_installer tool.""" @@ -41,12 +39,6 @@ def parser(**kwargs: Any) -> argparse.ArgumentParser: action="store", help="Extra arguments to pass down to pip.", ) - parser.add_argument( - "--platform", - action="extend", - type=Platform.from_string, - help="Platforms to target dependencies. Can be used multiple times.", - ) parser.add_argument( "--pip_data_exclude", action="store", diff --git a/python/private/pypi/whl_installer/platform.py b/python/private/pypi/whl_installer/platform.py deleted file mode 100644 index 83e42b0e46..0000000000 --- a/python/private/pypi/whl_installer/platform.py +++ /dev/null @@ -1,302 +0,0 @@ -# Copyright 2024 The Bazel Authors. All rights reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -"""Utility class to inspect an extracted wheel directory""" - -import platform -import sys -from dataclasses import dataclass -from enum import Enum -from typing import Any, Dict, Iterator, List, Optional, Union - - -class OS(Enum): - linux = 1 - osx = 2 - windows = 3 - darwin = osx - win32 = windows - - @classmethod - def interpreter(cls) -> "OS": - "Return the interpreter operating system." - return cls[sys.platform.lower()] - - def __str__(self) -> str: - return self.name.lower() - - -class Arch(Enum): - x86_64 = 1 - x86_32 = 2 - aarch64 = 3 - ppc = 4 - s390x = 5 - arm = 6 - amd64 = x86_64 - arm64 = aarch64 - i386 = x86_32 - i686 = x86_32 - x86 = x86_32 - ppc64le = ppc - - @classmethod - def interpreter(cls) -> "Arch": - "Return the currently running interpreter architecture." - # FIXME @aignas 2023-12-13: Hermetic toolchain on Windows 3.11.6 - # is returning an empty string here, so lets default to x86_64 - return cls[platform.machine().lower() or "x86_64"] - - def __str__(self) -> str: - return self.name.lower() - - -def _as_int(value: Optional[Union[OS, Arch]]) -> int: - """Convert one of the enums above to an int for easier sorting algorithms. - - Args: - value: The value of an enum or None. - - Returns: - -1 if we get None, otherwise, the numeric value of the given enum. - """ - if value is None: - return -1 - - return int(value.value) - - -def host_interpreter_minor_version() -> int: - return sys.version_info.minor - - -@dataclass(frozen=True) -class Platform: - os: Optional[OS] = None - arch: Optional[Arch] = None - minor_version: Optional[int] = None - - @classmethod - def all( - cls, - want_os: Optional[OS] = None, - minor_version: Optional[int] = None, - ) -> List["Platform"]: - return sorted( - [ - cls(os=os, arch=arch, minor_version=minor_version) - for os in OS - for arch in Arch - if not want_os or want_os == os - ] - ) - - @classmethod - def host(cls) -> List["Platform"]: - """Use the Python interpreter to detect the platform. - - We extract `os` from sys.platform and `arch` from platform.machine - - Returns: - A list of parsed values which makes the signature the same as - `Platform.all` and `Platform.from_string`. - """ - return [ - Platform( - os=OS.interpreter(), - arch=Arch.interpreter(), - minor_version=host_interpreter_minor_version(), - ) - ] - - def all_specializations(self) -> Iterator["Platform"]: - """Return the platform itself and all its unambiguous specializations. - - For more info about specializations see - https://bazel.build/docs/configurable-attributes - """ - yield self - if self.arch is None: - for arch in Arch: - yield Platform(os=self.os, arch=arch, minor_version=self.minor_version) - if self.os is None: - for os in OS: - yield Platform(os=os, arch=self.arch, minor_version=self.minor_version) - if self.arch is None and self.os is None: - for os in OS: - for arch in Arch: - yield Platform(os=os, arch=arch, minor_version=self.minor_version) - - def __lt__(self, other: Any) -> bool: - """Add a comparison method, so that `sorted` returns the most specialized platforms first.""" - if not isinstance(other, Platform) or other is None: - raise ValueError(f"cannot compare {other} with Platform") - - self_arch, self_os = _as_int(self.arch), _as_int(self.os) - other_arch, other_os = _as_int(other.arch), _as_int(other.os) - - if self_os == other_os: - return self_arch < other_arch - else: - return self_os < other_os - - def __str__(self) -> str: - if self.minor_version is None: - if self.os is None and self.arch is None: - return "//conditions:default" - - if self.arch is None: - return f"@platforms//os:{self.os}" - else: - return f"{self.os}_{self.arch}" - - if self.arch is None and self.os is None: - return f"@//python/config_settings:is_python_3.{self.minor_version}" - - if self.arch is None: - return f"cp3{self.minor_version}_{self.os}_anyarch" - - if self.os is None: - return f"cp3{self.minor_version}_anyos_{self.arch}" - - return f"cp3{self.minor_version}_{self.os}_{self.arch}" - - @classmethod - def from_string(cls, platform: Union[str, List[str]]) -> List["Platform"]: - """Parse a string and return a list of platforms""" - platform = [platform] if isinstance(platform, str) else list(platform) - ret = set() - for p in platform: - if p == "host": - ret.update(cls.host()) - continue - - abi, _, tail = p.partition("_") - if not abi.startswith("cp"): - # The first item is not an abi - tail = p - abi = "" - os, _, arch = tail.partition("_") - arch = arch or "*" - - minor_version = int(abi[len("cp3") :]) if abi else None - - if arch != "*": - ret.add( - cls( - os=OS[os] if os != "*" else None, - arch=Arch[arch], - minor_version=minor_version, - ) - ) - - else: - ret.update( - cls.all( - want_os=OS[os] if os != "*" else None, - minor_version=minor_version, - ) - ) - - return sorted(ret) - - # NOTE @aignas 2023-12-05: below is the minimum number of accessors that are defined in - # https://peps.python.org/pep-0496/ to make rules_python generate dependencies. - # - # WARNING: It may not work in cases where the python implementation is different between - # different platforms. - - # derived from OS - @property - def os_name(self) -> str: - if self.os == OS.linux or self.os == OS.osx: - return "posix" - elif self.os == OS.windows: - return "nt" - else: - return "" - - @property - def sys_platform(self) -> str: - if self.os == OS.linux: - return "linux" - elif self.os == OS.osx: - return "darwin" - elif self.os == OS.windows: - return "win32" - else: - return "" - - @property - def platform_system(self) -> str: - if self.os == OS.linux: - return "Linux" - elif self.os == OS.osx: - return "Darwin" - elif self.os == OS.windows: - return "Windows" - else: - return "" - - # derived from OS and Arch - @property - def platform_machine(self) -> str: - """Guess the target 'platform_machine' marker. - - NOTE @aignas 2023-12-05: this may not work on really new systems, like - Windows if they define the platform markers in a different way. - """ - if self.arch == Arch.x86_64: - return "x86_64" - elif self.arch == Arch.x86_32 and self.os != OS.osx: - return "i386" - elif self.arch == Arch.x86_32: - return "" - elif self.arch == Arch.aarch64 and self.os == OS.linux: - return "aarch64" - elif self.arch == Arch.aarch64: - # Assuming that OSX and Windows use this one since the precedent is set here: - # https://github.com/cgohlke/win_arm64-wheels - return "arm64" - elif self.os != OS.linux: - return "" - elif self.arch == Arch.ppc64le: - return "ppc64le" - elif self.arch == Arch.s390x: - return "s390x" - else: - return "" - - def env_markers(self, extra: str) -> Dict[str, str]: - # If it is None, use the host version - minor_version = self.minor_version or host_interpreter_minor_version() - - return { - "extra": extra, - "os_name": self.os_name, - "sys_platform": self.sys_platform, - "platform_machine": self.platform_machine, - "platform_system": self.platform_system, - "platform_release": "", # unset - "platform_version": "", # unset - "python_version": f"3.{minor_version}", - # FIXME @aignas 2024-01-14: is putting zero last a good idea? Maybe we should - # use `20` or something else to avoid having weird issues where the full version is used for - # matching and the author decides to only support 3.y.5 upwards. - "implementation_version": f"3.{minor_version}.0", - "python_full_version": f"3.{minor_version}.0", - # we assume that the following are the same as the interpreter used to setup the deps: - # "implementation_name": "cpython" - # "platform_python_implementation: "CPython", - } diff --git a/python/private/pypi/whl_installer/wheel.py b/python/private/pypi/whl_installer/wheel.py index af71942614..3ba402e242 100644 --- a/python/private/pypi/whl_installer/wheel.py +++ b/python/private/pypi/whl_installer/wheel.py @@ -25,276 +25,6 @@ from packaging.requirements import Requirement from pip._vendor.packaging.utils import canonicalize_name -from python.private.pypi.whl_installer.platform import ( - Platform, - host_interpreter_minor_version, -) - - -@dataclass(frozen=True) -class FrozenDeps: - deps: List[str] - deps_select: Dict[str, List[str]] - - -class Deps: - """Deps is a dependency builder that has a build() method to return FrozenDeps.""" - - def __init__( - self, - name: str, - requires_dist: List[str], - *, - extras: Optional[Set[str]] = None, - platforms: Optional[Set[Platform]] = None, - ): - """Create a new instance and parse the requires_dist - - Args: - name (str): The name of the whl distribution - requires_dist (list[Str]): The Requires-Dist from the METADATA of the whl - distribution. - extras (set[str], optional): The list of requested extras, defaults to None. - platforms (set[Platform], optional): The list of target platforms, defaults to - None. If the list of platforms has multiple `minor_version` values, it - will change the code to generate the select statements using - `@rules_python//python/config_settings:is_python_3.y` conditions. - """ - self.name: str = Deps._normalize(name) - self._platforms: Set[Platform] = platforms or set() - self._target_versions = {p.minor_version for p in platforms or {}} - - self._default_minor_version = None - if platforms and len(self._target_versions) > 2: - # TODO @aignas 2024-06-23: enable this to be set via a CLI arg - # for being more explicit. - self._default_minor_version = host_interpreter_minor_version() - - if None in self._target_versions and len(self._target_versions) > 2: - raise ValueError( - f"all python versions need to be specified explicitly, got: {platforms}" - ) - - # Sort so that the dictionary order in the FrozenDeps is deterministic - # without the final sort because Python retains insertion order. That way - # the sorting by platform is limited within the Platform class itself and - # the unit-tests for the Deps can be simpler. - reqs = sorted( - (Requirement(wheel_req) for wheel_req in requires_dist), - key=lambda x: f"{x.name}:{sorted(x.extras)}", - ) - - want_extras = self._resolve_extras(reqs, extras) - - # Then add all of the requirements in order - self._deps: Set[str] = set() - self._select: Dict[Platform, Set[str]] = defaultdict(set) - for req in reqs: - self._add_req(req, want_extras) - - def _add(self, dep: str, platform: Optional[Platform]): - dep = Deps._normalize(dep) - - # Self-edges are processed in _resolve_extras - if dep == self.name: - return - - if not platform: - self._deps.add(dep) - - # If the dep is in the platform-specific list, remove it from the select. - pop_keys = [] - for p, deps in self._select.items(): - if dep not in deps: - continue - - deps.remove(dep) - if not deps: - pop_keys.append(p) - - for p in pop_keys: - self._select.pop(p) - return - - if dep in self._deps: - # If the dep is already in the main dependency list, no need to add it in the - # platform-specific dependency list. - return - - # Add the platform-specific dep - self._select[platform].add(dep) - - # Add the dep to specializations of the given platform if they - # exist in the select statement. - for p in platform.all_specializations(): - if p not in self._select: - continue - - self._select[p].add(dep) - - if len(self._select[platform]) == 1: - # We are adding a new item to the select and we need to ensure that - # existing dependencies from less specialized platforms are propagated - # to the newly added dependency set. - for p, deps in self._select.items(): - # Check if the existing platform overlaps with the given platform - if p == platform or platform not in p.all_specializations(): - continue - - self._select[platform].update(self._select[p]) - - def _maybe_add_common_dep(self, dep): - if len(self._target_versions) < 2: - return - - platforms = [Platform()] + [ - Platform(minor_version=v) for v in self._target_versions - ] - - # If the dep is targeting all target python versions, lets add it to - # the common dependency list to simplify the select statements. - for p in platforms: - if p not in self._select: - return - - if dep not in self._select[p]: - return - - # All of the python version-specific branches have the dep, so lets add - # it to the common deps. - self._deps.add(dep) - for p in platforms: - self._select[p].remove(dep) - if not self._select[p]: - self._select.pop(p) - - @staticmethod - def _normalize(name: str) -> str: - return re.sub(r"[-_.]+", "_", name).lower() - - def _resolve_extras( - self, reqs: List[Requirement], extras: Optional[Set[str]] - ) -> Set[str]: - """Resolve extras which are due to depending on self[some_other_extra]. - - Some packages may have cyclic dependencies resulting from extras being used, one example is - `etils`, where we have one set of extras as aliases for other extras - and we have an extra called 'all' that includes all other extras. - - Example: github.com/google/etils/blob/a0b71032095db14acf6b33516bca6d885fe09e35/pyproject.toml#L32. - - When the `requirements.txt` is generated by `pip-tools`, then it is likely that - this step is not needed, but for other `requirements.txt` files this may be useful. - - NOTE @aignas 2023-12-08: the extra resolution is not platform dependent, - but in order for it to become platform dependent we would have to have - separate targets for each extra in extras. - """ - - # Resolve any extra extras due to self-edges, empty string means no - # extras The empty string in the set is just a way to make the handling - # of no extras and a single extra easier and having a set of {"", "foo"} - # is equivalent to having {"foo"}. - extras = extras or {""} - - self_reqs = [] - for req in reqs: - if Deps._normalize(req.name) != self.name: - continue - - if req.marker is None: - # I am pretty sure we cannot reach this code as it does not - # make sense to specify packages in this way, but since it is - # easy to handle, lets do it. - # - # TODO @aignas 2023-12-08: add a test - extras = extras | req.extras - else: - # process these in a separate loop - self_reqs.append(req) - - # A double loop is not strictly optimal, but always correct without recursion - for req in self_reqs: - if any(req.marker.evaluate({"extra": extra}) for extra in extras): - extras = extras | req.extras - else: - continue - - # Iterate through all packages to ensure that we include all of the extras from previously - # visited packages. - for req_ in self_reqs: - if any(req_.marker.evaluate({"extra": extra}) for extra in extras): - extras = extras | req_.extras - - return extras - - def _add_req(self, req: Requirement, extras: Set[str]) -> None: - if req.marker is None: - self._add(req.name, None) - return - - marker_str = str(req.marker) - - if not self._platforms: - if any(req.marker.evaluate({"extra": extra}) for extra in extras): - self._add(req.name, None) - return - - # NOTE @aignas 2023-12-08: in order to have reasonable select statements - # we do have to have some parsing of the markers, so it begs the question - # if packaging should be reimplemented in Starlark to have the best solution - # for now we will implement it in Python and see what the best parsing result - # can be before making this decision. - match_os = any( - tag in marker_str - for tag in [ - "os_name", - "sys_platform", - "platform_system", - ] - ) - match_arch = "platform_machine" in marker_str - match_version = "version" in marker_str - - if not (match_os or match_arch or match_version): - if any(req.marker.evaluate({"extra": extra}) for extra in extras): - self._add(req.name, None) - return - - for plat in self._platforms: - if not any( - req.marker.evaluate(plat.env_markers(extra)) for extra in extras - ): - continue - - if match_arch and self._default_minor_version: - self._add(req.name, plat) - if plat.minor_version == self._default_minor_version: - self._add(req.name, Platform(plat.os, plat.arch)) - elif match_arch: - self._add(req.name, Platform(plat.os, plat.arch)) - elif match_os and self._default_minor_version: - self._add(req.name, Platform(plat.os, minor_version=plat.minor_version)) - if plat.minor_version == self._default_minor_version: - self._add(req.name, Platform(plat.os)) - elif match_os: - self._add(req.name, Platform(plat.os)) - elif match_version and self._default_minor_version: - self._add(req.name, Platform(minor_version=plat.minor_version)) - if plat.minor_version == self._default_minor_version: - self._add(req.name, Platform()) - elif match_version: - self._add(req.name, None) - - # Merge to common if possible after processing all platforms - self._maybe_add_common_dep(req.name) - - def build(self) -> FrozenDeps: - return FrozenDeps( - deps=sorted(self._deps), - deps_select={str(p): sorted(deps) for p, deps in self._select.items()}, - ) - class Wheel: """Representation of the compressed .whl file""" @@ -345,18 +75,6 @@ def entry_points(self) -> Dict[str, Tuple[str, str]]: return entry_points_mapping - def dependencies( - self, - extras_requested: Set[str] = None, - platforms: Optional[Set[Platform]] = None, - ) -> FrozenDeps: - return Deps( - self.name, - extras=extras_requested, - platforms=platforms, - requires_dist=self.metadata.get_all("Requires-Dist", []), - ).build() - def unzip(self, directory: str) -> None: installation_schemes = { "purelib": "/site-packages", diff --git a/python/private/pypi/whl_installer/wheel_installer.py b/python/private/pypi/whl_installer/wheel_installer.py index ef8181c30d..802f280287 100644 --- a/python/private/pypi/whl_installer/wheel_installer.py +++ b/python/private/pypi/whl_installer/wheel_installer.py @@ -23,7 +23,7 @@ import sys from pathlib import Path from tempfile import NamedTemporaryFile -from typing import Dict, List, Optional, Set, Tuple +from typing import Dict, Optional, Set, Tuple from pip._vendor.packaging.utils import canonicalize_name @@ -105,7 +105,6 @@ def _extract_wheel( wheel_file: str, extras: Dict[str, Set[str]], enable_implicit_namespace_pkgs: bool, - platforms: List[wheel.Platform], installation_dir: Path = Path("."), ) -> None: """Extracts wheel into given directory and creates py_library and filegroup targets. @@ -124,24 +123,26 @@ def _extract_wheel( _setup_namespace_pkg_compatibility(installation_dir) extras_requested = extras[whl.name] if whl.name in extras else set() - - dependencies = whl.dependencies(extras_requested, platforms) + requires_dist = whl.metadata.get_all("Requires-Dist", []) + abi = f"cp{sys.version_info.major}{sys.version_info.minor}" + metadata = { + "name": whl.name, + "version": whl.version, + "extras": list(extras_requested), + "requires_dist": requires_dist, + "abi": abi, + "entry_points": [ + { + "name": name, + "module": module, + "attribute": attribute, + } + for name, (module, attribute) in sorted(whl.entry_points().items()) + ], + } + print(metadata) with open(os.path.join(installation_dir, "metadata.json"), "w") as f: - metadata = { - "name": whl.name, - "version": whl.version, - "deps": dependencies.deps, - "deps_by_platform": dependencies.deps_select, - "entry_points": [ - { - "name": name, - "module": module, - "attribute": attribute, - } - for name, (module, attribute) in sorted(whl.entry_points().items()) - ], - } json.dump(metadata, f) @@ -161,7 +162,6 @@ def main() -> None: wheel_file=whl, extras=extras, enable_implicit_namespace_pkgs=args.enable_implicit_namespace_pkgs, - platforms=arguments.get_platforms(args), ) return diff --git a/python/private/pypi/whl_library.bzl b/python/private/pypi/whl_library.bzl index ef4077fa41..b8e58b3a84 100644 --- a/python/private/pypi/whl_library.bzl +++ b/python/private/pypi/whl_library.bzl @@ -21,8 +21,10 @@ load("//python/private:repo_utils.bzl", "REPO_DEBUG_ENV_VAR", "repo_utils") load(":attrs.bzl", "ATTRS", "use_isolated") load(":deps.bzl", "all_repo_names", "record_files") load(":generate_whl_library_build_bazel.bzl", "generate_whl_library_build_bazel") +load(":parse_requirements.bzl", "host_platform") load(":parse_whl_name.bzl", "parse_whl_name") load(":patch_whl.bzl", "patch_whl") +load(":pep508_env.bzl", "deps") load(":pypi_repo_utils.bzl", "pypi_repo_utils") load(":whl_target_platforms.bzl", "whl_target_platforms") @@ -298,7 +300,7 @@ def _whl_library_impl(rctx): arguments = args + [ "--whl-file", whl_path, - ] + ["--platform={}".format(p) for p in target_platforms], + ], srcs = rctx.attr._python_srcs, environment = environment, quiet = rctx.attr.quiet, @@ -333,11 +335,23 @@ def _whl_library_impl(rctx): ) entry_points[entry_point_without_py] = entry_point_script_name + package_deps = deps( + name = metadata["name"], + requires_dist = metadata["requires_dist"], + # target the host platform if the target platform is not specified in the rule. + # TODO @aignas 2025-02-24: move this to pkg_aliases layer to have this in the + # analysis phase. + platforms = target_platforms or [ + "{}_{}".format(metadata["abi"], host_platform(rctx)), + ], + extras = metadata["extras"], + ) + build_file_contents = generate_whl_library_build_bazel( name = whl_path.basename, dep_template = rctx.attr.dep_template or "@{}{{name}}//:{{target}}".format(rctx.attr.repo_prefix), - dependencies = metadata["deps"], - dependencies_by_platform = metadata["deps_by_platform"], + dependencies = package_deps.deps, + dependencies_by_platform = package_deps.deps_select, group_name = rctx.attr.group_name, group_deps = rctx.attr.group_deps, data_exclude = rctx.attr.pip_data_exclude, From 62df3ac51de89cf153dff541bd5c2d3eec7b1446 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Mon, 24 Feb 2025 01:15:32 +0900 Subject: [PATCH 40/65] remove the MODULE.bazel.lock --- MODULE.bazel.lock | 6688 --------------------------------------------- 1 file changed, 6688 deletions(-) delete mode 100644 MODULE.bazel.lock diff --git a/MODULE.bazel.lock b/MODULE.bazel.lock deleted file mode 100644 index 9a284d90a3..0000000000 --- a/MODULE.bazel.lock +++ /dev/null @@ -1,6688 +0,0 @@ -{ - "lockFileVersion": 18, - "registryFileHashes": { - "https://bcr.bazel.build/bazel_registry.json": "8a28e4aff06ee60aed2a8c281907fb8bcbf3b753c91fb5a5c57da3215d5b3497", - "https://bcr.bazel.build/modules/abseil-cpp/20210324.2/MODULE.bazel": "7cd0312e064fde87c8d1cd79ba06c876bd23630c83466e9500321be55c96ace2", - "https://bcr.bazel.build/modules/abseil-cpp/20211102.0/MODULE.bazel": "70390338f7a5106231d20620712f7cccb659cd0e9d073d1991c038eb9fc57589", - "https://bcr.bazel.build/modules/abseil-cpp/20230125.1/MODULE.bazel": "89047429cb0207707b2dface14ba7f8df85273d484c2572755be4bab7ce9c3a0", - "https://bcr.bazel.build/modules/abseil-cpp/20230802.0.bcr.1/MODULE.bazel": "1c8cec495288dccd14fdae6e3f95f772c1c91857047a098fad772034264cc8cb", - "https://bcr.bazel.build/modules/abseil-cpp/20230802.0/MODULE.bazel": "d253ae36a8bd9ee3c5955384096ccb6baf16a1b1e93e858370da0a3b94f77c16", - "https://bcr.bazel.build/modules/abseil-cpp/20230802.1/MODULE.bazel": "fa92e2eb41a04df73cdabeec37107316f7e5272650f81d6cc096418fe647b915", - "https://bcr.bazel.build/modules/abseil-cpp/20240116.1/MODULE.bazel": "37bcdb4440fbb61df6a1c296ae01b327f19e9bb521f9b8e26ec854b6f97309ed", - "https://bcr.bazel.build/modules/abseil-cpp/20240116.1/source.json": "9be551b8d4e3ef76875c0d744b5d6a504a27e3ae67bc6b28f46415fd2d2957da", - "https://bcr.bazel.build/modules/bazel_ci_rules/1.0.0/MODULE.bazel": "0f92c944b9c466066ed484cfc899cf43fca765df78caca18984c62479f7925eb", - "https://bcr.bazel.build/modules/bazel_ci_rules/1.0.0/source.json": "3405a2a7f9f827a44934b01470faeac1b56fb1304955c98ee9fcd03ad2ca5dcc", - "https://bcr.bazel.build/modules/bazel_features/1.1.0/MODULE.bazel": "cfd42ff3b815a5f39554d97182657f8c4b9719568eb7fded2b9135f084bf760b", - "https://bcr.bazel.build/modules/bazel_features/1.1.1/MODULE.bazel": "27b8c79ef57efe08efccbd9dd6ef70d61b4798320b8d3c134fd571f78963dbcd", - "https://bcr.bazel.build/modules/bazel_features/1.11.0/MODULE.bazel": "f9382337dd5a474c3b7d334c2f83e50b6eaedc284253334cf823044a26de03e8", - "https://bcr.bazel.build/modules/bazel_features/1.15.0/MODULE.bazel": "d38ff6e517149dc509406aca0db3ad1efdd890a85e049585b7234d04238e2a4d", - "https://bcr.bazel.build/modules/bazel_features/1.17.0/MODULE.bazel": "039de32d21b816b47bd42c778e0454217e9c9caac4a3cf8e15c7231ee3ddee4d", - "https://bcr.bazel.build/modules/bazel_features/1.18.0/MODULE.bazel": "1be0ae2557ab3a72a57aeb31b29be347bcdc5d2b1eb1e70f39e3851a7e97041a", - "https://bcr.bazel.build/modules/bazel_features/1.19.0/MODULE.bazel": "59adcdf28230d220f0067b1f435b8537dd033bfff8db21335ef9217919c7fb58", - "https://bcr.bazel.build/modules/bazel_features/1.21.0/MODULE.bazel": "675642261665d8eea09989aa3b8afb5c37627f1be178382c320d1b46afba5e3b", - "https://bcr.bazel.build/modules/bazel_features/1.21.0/source.json": "3e8379efaaef53ce35b7b8ba419df829315a880cb0a030e5bb45c96d6d5ecb5f", - "https://bcr.bazel.build/modules/bazel_features/1.4.1/MODULE.bazel": "e45b6bb2350aff3e442ae1111c555e27eac1d915e77775f6fdc4b351b758b5d7", - "https://bcr.bazel.build/modules/bazel_features/1.9.1/MODULE.bazel": "8f679097876a9b609ad1f60249c49d68bfab783dd9be012faf9d82547b14815a", - "https://bcr.bazel.build/modules/bazel_skylib/1.0.3/MODULE.bazel": "bcb0fd896384802d1ad283b4e4eb4d718eebd8cb820b0a2c3a347fb971afd9d8", - "https://bcr.bazel.build/modules/bazel_skylib/1.1.1/MODULE.bazel": "1add3e7d93ff2e6998f9e118022c84d163917d912f5afafb3058e3d2f1545b5e", - "https://bcr.bazel.build/modules/bazel_skylib/1.2.0/MODULE.bazel": "44fe84260e454ed94ad326352a698422dbe372b21a1ac9f3eab76eb531223686", - "https://bcr.bazel.build/modules/bazel_skylib/1.2.1/MODULE.bazel": "f35baf9da0efe45fa3da1696ae906eea3d615ad41e2e3def4aeb4e8bc0ef9a7a", - "https://bcr.bazel.build/modules/bazel_skylib/1.3.0/MODULE.bazel": "20228b92868bf5cfc41bda7afc8a8ba2a543201851de39d990ec957b513579c5", - "https://bcr.bazel.build/modules/bazel_skylib/1.4.1/MODULE.bazel": "a0dcb779424be33100dcae821e9e27e4f2901d9dfd5333efe5ac6a8d7ab75e1d", - "https://bcr.bazel.build/modules/bazel_skylib/1.4.2/MODULE.bazel": "3bd40978e7a1fac911d5989e6b09d8f64921865a45822d8b09e815eaa726a651", - "https://bcr.bazel.build/modules/bazel_skylib/1.5.0/MODULE.bazel": "32880f5e2945ce6a03d1fbd588e9198c0a959bb42297b2cfaf1685b7bc32e138", - "https://bcr.bazel.build/modules/bazel_skylib/1.6.1/MODULE.bazel": "8fdee2dbaace6c252131c00e1de4b165dc65af02ea278476187765e1a617b917", - "https://bcr.bazel.build/modules/bazel_skylib/1.7.0/MODULE.bazel": "0db596f4563de7938de764cc8deeabec291f55e8ec15299718b93c4423e9796d", - "https://bcr.bazel.build/modules/bazel_skylib/1.7.1/MODULE.bazel": "3120d80c5861aa616222ec015332e5f8d3171e062e3e804a2a0253e1be26e59b", - "https://bcr.bazel.build/modules/bazel_skylib/1.7.1/source.json": "f121b43eeefc7c29efbd51b83d08631e2347297c95aac9764a701f2a6a2bb953", - "https://bcr.bazel.build/modules/buildifier_prebuilt/6.0.0.1/MODULE.bazel": "5d23708e6a5527ab4f151da7accabc22808cb5fb579c8cc4cd4a292da57a5c97", - "https://bcr.bazel.build/modules/buildifier_prebuilt/6.1.2/MODULE.bazel": "2ef4962c8b0b6d8d21928a89190755619254459bc67f870dc0ccb9ba9952d444", - "https://bcr.bazel.build/modules/buildifier_prebuilt/6.1.2/source.json": "19fb45ed3f0d55cbff94e402c39512940833ae3a68f9cbfd9518a1926b609c7c", - "https://bcr.bazel.build/modules/buildozer/7.1.2/MODULE.bazel": "2e8dd40ede9c454042645fd8d8d0cd1527966aa5c919de86661e62953cd73d84", - "https://bcr.bazel.build/modules/buildozer/7.1.2/source.json": "c9028a501d2db85793a6996205c8de120944f50a0d570438fcae0457a5f9d1f8", - "https://bcr.bazel.build/modules/cgrindel_bazel_starlib/0.18.0/MODULE.bazel": "1d548f0c383ec8fce15c14b42b7f5f4fc29e910fb747d54b40d8c949a5dea09c", - "https://bcr.bazel.build/modules/cgrindel_bazel_starlib/0.18.0/source.json": "bb5421fffcf03965cb192a7dfa857c4cfc2d5ed7788d8b97da30f6b9d5706c9e", - "https://bcr.bazel.build/modules/gazelle/0.32.0/MODULE.bazel": "b499f58a5d0d3537f3cf5b76d8ada18242f64ec474d8391247438bf04f58c7b8", - "https://bcr.bazel.build/modules/gazelle/0.33.0/MODULE.bazel": "a13a0f279b462b784fb8dd52a4074526c4a2afe70e114c7d09066097a46b3350", - "https://bcr.bazel.build/modules/gazelle/0.34.0/MODULE.bazel": "abdd8ce4d70978933209db92e436deb3a8b737859e9354fb5fd11fb5c2004c8a", - "https://bcr.bazel.build/modules/gazelle/0.36.0/MODULE.bazel": "e375d5d6e9a6ca59b0cb38b0540bc9a05b6aa926d322f2de268ad267a2ee74c0", - "https://bcr.bazel.build/modules/gazelle/0.40.0/MODULE.bazel": "42ba5378ebe845fca43989a53186ab436d956db498acde790685fe0e8f9c6146", - "https://bcr.bazel.build/modules/gazelle/0.40.0/source.json": "1e5ef6e4d8b9b6836d93273c781e78ff829ea2e077afef7a57298040fa4f010a", - "https://bcr.bazel.build/modules/google_benchmark/1.8.2/MODULE.bazel": "a70cf1bba851000ba93b58ae2f6d76490a9feb74192e57ab8e8ff13c34ec50cb", - "https://bcr.bazel.build/modules/googletest/1.11.0/MODULE.bazel": "3a83f095183f66345ca86aa13c58b59f9f94a2f81999c093d4eeaa2d262d12f4", - "https://bcr.bazel.build/modules/googletest/1.14.0.bcr.1/MODULE.bazel": "22c31a561553727960057361aa33bf20fb2e98584bc4fec007906e27053f80c6", - "https://bcr.bazel.build/modules/googletest/1.14.0.bcr.1/source.json": "41e9e129f80d8c8bf103a7acc337b76e54fad1214ac0a7084bf24f4cd924b8b4", - "https://bcr.bazel.build/modules/googletest/1.14.0/MODULE.bazel": "cfbcbf3e6eac06ef9d85900f64424708cc08687d1b527f0ef65aa7517af8118f", - "https://bcr.bazel.build/modules/jsoncpp/1.9.5/MODULE.bazel": "31271aedc59e815656f5736f282bb7509a97c7ecb43e927ac1a37966e0578075", - "https://bcr.bazel.build/modules/jsoncpp/1.9.5/source.json": "4108ee5085dd2885a341c7fab149429db457b3169b86eb081fa245eadf69169d", - "https://bcr.bazel.build/modules/libpfm/4.11.0/MODULE.bazel": "45061ff025b301940f1e30d2c16bea596c25b176c8b6b3087e92615adbd52902", - "https://bcr.bazel.build/modules/platforms/0.0.10/MODULE.bazel": "8cb8efaf200bdeb2150d93e162c40f388529a25852b332cec879373771e48ed5", - "https://bcr.bazel.build/modules/platforms/0.0.10/source.json": "f22828ff4cf021a6b577f1bf6341cb9dcd7965092a439f64fc1bb3b7a5ae4bd5", - "https://bcr.bazel.build/modules/platforms/0.0.4/MODULE.bazel": "9b328e31ee156f53f3c416a64f8491f7eb731742655a47c9eec4703a71644aee", - "https://bcr.bazel.build/modules/platforms/0.0.5/MODULE.bazel": "5733b54ea419d5eaf7997054bb55f6a1d0b5ff8aedf0176fef9eea44f3acda37", - "https://bcr.bazel.build/modules/platforms/0.0.6/MODULE.bazel": "ad6eeef431dc52aefd2d77ed20a4b353f8ebf0f4ecdd26a807d2da5aa8cd0615", - "https://bcr.bazel.build/modules/platforms/0.0.7/MODULE.bazel": "72fd4a0ede9ee5c021f6a8dd92b503e089f46c227ba2813ff183b71616034814", - "https://bcr.bazel.build/modules/platforms/0.0.8/MODULE.bazel": "9f142c03e348f6d263719f5074b21ef3adf0b139ee4c5133e2aa35664da9eb2d", - "https://bcr.bazel.build/modules/protobuf/21.7/MODULE.bazel": "a5a29bb89544f9b97edce05642fac225a808b5b7be74038ea3640fae2f8e66a7", - "https://bcr.bazel.build/modules/protobuf/27.0/MODULE.bazel": "7873b60be88844a0a1d8f80b9d5d20cfbd8495a689b8763e76c6372998d3f64c", - "https://bcr.bazel.build/modules/protobuf/27.1/MODULE.bazel": "703a7b614728bb06647f965264967a8ef1c39e09e8f167b3ca0bb1fd80449c0d", - "https://bcr.bazel.build/modules/protobuf/29.0-rc2/MODULE.bazel": "6241d35983510143049943fc0d57937937122baf1b287862f9dc8590fc4c37df", - "https://bcr.bazel.build/modules/protobuf/29.0-rc3/MODULE.bazel": "33c2dfa286578573afc55a7acaea3cada4122b9631007c594bf0729f41c8de92", - "https://bcr.bazel.build/modules/protobuf/29.0/MODULE.bazel": "319dc8bf4c679ff87e71b1ccfb5a6e90a6dbc4693501d471f48662ac46d04e4e", - "https://bcr.bazel.build/modules/protobuf/29.0/source.json": "b857f93c796750eef95f0d61ee378f3420d00ee1dd38627b27193aa482f4f981", - "https://bcr.bazel.build/modules/protobuf/3.19.0/MODULE.bazel": "6b5fbb433f760a99a22b18b6850ed5784ef0e9928a72668b66e4d7ccd47db9b0", - "https://bcr.bazel.build/modules/protobuf/3.19.2/MODULE.bazel": "532ffe5f2186b69fdde039efe6df13ba726ff338c6bc82275ad433013fa10573", - "https://bcr.bazel.build/modules/protobuf/3.19.6/MODULE.bazel": "9233edc5e1f2ee276a60de3eaa47ac4132302ef9643238f23128fea53ea12858", - "https://bcr.bazel.build/modules/pybind11_bazel/2.11.1/MODULE.bazel": "88af1c246226d87e65be78ed49ecd1e6f5e98648558c14ce99176da041dc378e", - "https://bcr.bazel.build/modules/pybind11_bazel/2.11.1/source.json": "be4789e951dd5301282729fe3d4938995dc4c1a81c2ff150afc9f1b0504c6022", - "https://bcr.bazel.build/modules/re2/2023-09-01/MODULE.bazel": "cb3d511531b16cfc78a225a9e2136007a48cf8a677e4264baeab57fe78a80206", - "https://bcr.bazel.build/modules/re2/2023-09-01/source.json": "e044ce89c2883cd957a2969a43e79f7752f9656f6b20050b62f90ede21ec6eb4", - "https://bcr.bazel.build/modules/rules_android/0.1.1/MODULE.bazel": "48809ab0091b07ad0182defb787c4c5328bd3a278938415c00a7b69b50c4d3a8", - "https://bcr.bazel.build/modules/rules_android/0.1.1/source.json": "e6986b41626ee10bdc864937ffb6d6bf275bb5b9c65120e6137d56e6331f089e", - "https://bcr.bazel.build/modules/rules_bazel_integration_test/0.27.0/MODULE.bazel": "66b85a47d4aa51686c3e43befc7442b5be84415b12296954929ba199d46823be", - "https://bcr.bazel.build/modules/rules_bazel_integration_test/0.27.0/source.json": "28bd34e4cbbe78a826aa513cf555d9cb52f0fe589b64d20ca812b8e3fbca572f", - "https://bcr.bazel.build/modules/rules_cc/0.0.1/MODULE.bazel": "cb2aa0747f84c6c3a78dad4e2049c154f08ab9d166b1273835a8174940365647", - "https://bcr.bazel.build/modules/rules_cc/0.0.10/MODULE.bazel": "ec1705118f7eaedd6e118508d3d26deba2a4e76476ada7e0e3965211be012002", - "https://bcr.bazel.build/modules/rules_cc/0.0.13/MODULE.bazel": "0e8529ed7b323dad0775ff924d2ae5af7640b23553dfcd4d34344c7e7a867191", - "https://bcr.bazel.build/modules/rules_cc/0.0.15/MODULE.bazel": "6704c35f7b4a72502ee81f61bf88706b54f06b3cbe5558ac17e2e14666cd5dcc", - "https://bcr.bazel.build/modules/rules_cc/0.0.16/MODULE.bazel": "7661303b8fc1b4d7f532e54e9d6565771fea666fbdf839e0a86affcd02defe87", - "https://bcr.bazel.build/modules/rules_cc/0.0.17/MODULE.bazel": "2ae1d8f4238ec67d7185d8861cb0a2cdf4bc608697c331b95bf990e69b62e64a", - "https://bcr.bazel.build/modules/rules_cc/0.0.17/source.json": "4db99b3f55c90ab28d14552aa0632533e3e8e5e9aea0f5c24ac0014282c2a7c5", - "https://bcr.bazel.build/modules/rules_cc/0.0.2/MODULE.bazel": "6915987c90970493ab97393024c156ea8fb9f3bea953b2f3ec05c34f19b5695c", - "https://bcr.bazel.build/modules/rules_cc/0.0.6/MODULE.bazel": "abf360251023dfe3efcef65ab9d56beefa8394d4176dd29529750e1c57eaa33f", - "https://bcr.bazel.build/modules/rules_cc/0.0.8/MODULE.bazel": "964c85c82cfeb6f3855e6a07054fdb159aced38e99a5eecf7bce9d53990afa3e", - "https://bcr.bazel.build/modules/rules_cc/0.0.9/MODULE.bazel": "836e76439f354b89afe6a911a7adf59a6b2518fafb174483ad78a2a2fde7b1c5", - "https://bcr.bazel.build/modules/rules_foreign_cc/0.9.0/MODULE.bazel": "c9e8c682bf75b0e7c704166d79b599f93b72cfca5ad7477df596947891feeef6", - "https://bcr.bazel.build/modules/rules_fuzzing/0.5.2/MODULE.bazel": "40c97d1144356f52905566c55811f13b299453a14ac7769dfba2ac38192337a8", - "https://bcr.bazel.build/modules/rules_fuzzing/0.5.2/source.json": "c8b1e2c717646f1702290959a3302a178fb639d987ab61d548105019f11e527e", - "https://bcr.bazel.build/modules/rules_go/0.41.0/MODULE.bazel": "55861d8e8bb0e62cbd2896f60ff303f62ffcb0eddb74ecb0e5c0cbe36fc292c8", - "https://bcr.bazel.build/modules/rules_go/0.42.0/MODULE.bazel": "8cfa875b9aa8c6fce2b2e5925e73c1388173ea3c32a0db4d2b4804b453c14270", - "https://bcr.bazel.build/modules/rules_go/0.46.0/MODULE.bazel": "3477df8bdcc49e698b9d25f734c4f3a9f5931ff34ee48a2c662be168f5f2d3fd", - "https://bcr.bazel.build/modules/rules_go/0.50.1/MODULE.bazel": "b91a308dc5782bb0a8021ad4330c81fea5bda77f96b9e4c117b9b9c8f6665ee0", - "https://bcr.bazel.build/modules/rules_go/0.50.1/source.json": "205765fd30216c70321f84c9a967267684bdc74350af3f3c46c857d9f80a4fa2", - "https://bcr.bazel.build/modules/rules_java/4.0.0/MODULE.bazel": "5a78a7ae82cd1a33cef56dc578c7d2a46ed0dca12643ee45edbb8417899e6f74", - "https://bcr.bazel.build/modules/rules_java/5.3.5/MODULE.bazel": "a4ec4f2db570171e3e5eb753276ee4b389bae16b96207e9d3230895c99644b86", - "https://bcr.bazel.build/modules/rules_java/6.0.0/MODULE.bazel": "8a43b7df601a7ec1af61d79345c17b31ea1fedc6711fd4abfd013ea612978e39", - "https://bcr.bazel.build/modules/rules_java/6.5.2/MODULE.bazel": "1d440d262d0e08453fa0c4d8f699ba81609ed0e9a9a0f02cd10b3e7942e61e31", - "https://bcr.bazel.build/modules/rules_java/7.10.0/MODULE.bazel": "530c3beb3067e870561739f1144329a21c851ff771cd752a49e06e3dc9c2e71a", - "https://bcr.bazel.build/modules/rules_java/7.12.2/MODULE.bazel": "579c505165ee757a4280ef83cda0150eea193eed3bef50b1004ba88b99da6de6", - "https://bcr.bazel.build/modules/rules_java/7.2.0/MODULE.bazel": "06c0334c9be61e6cef2c8c84a7800cef502063269a5af25ceb100b192453d4ab", - "https://bcr.bazel.build/modules/rules_java/7.6.1/MODULE.bazel": "2f14b7e8a1aa2f67ae92bc69d1ec0fa8d9f827c4e17ff5e5f02e91caa3b2d0fe", - "https://bcr.bazel.build/modules/rules_java/8.3.2/MODULE.bazel": "7336d5511ad5af0b8615fdc7477535a2e4e723a357b6713af439fe8cf0195017", - "https://bcr.bazel.build/modules/rules_java/8.5.1/MODULE.bazel": "d8a9e38cc5228881f7055a6079f6f7821a073df3744d441978e7a43e20226939", - "https://bcr.bazel.build/modules/rules_java/8.6.1/MODULE.bazel": "f4808e2ab5b0197f094cabce9f4b006a27766beb6a9975931da07099560ca9c2", - "https://bcr.bazel.build/modules/rules_java/8.6.1/source.json": "f18d9ad3c4c54945bf422ad584fa6c5ca5b3116ff55a5b1bc77e5c1210be5960", - "https://bcr.bazel.build/modules/rules_jvm_external/4.4.2/MODULE.bazel": "a56b85e418c83eb1839819f0b515c431010160383306d13ec21959ac412d2fe7", - "https://bcr.bazel.build/modules/rules_jvm_external/5.1/MODULE.bazel": "33f6f999e03183f7d088c9be518a63467dfd0be94a11d0055fe2d210f89aa909", - "https://bcr.bazel.build/modules/rules_jvm_external/5.2/MODULE.bazel": "d9351ba35217ad0de03816ef3ed63f89d411349353077348a45348b096615036", - "https://bcr.bazel.build/modules/rules_jvm_external/6.3/MODULE.bazel": "c998e060b85f71e00de5ec552019347c8bca255062c990ac02d051bb80a38df0", - "https://bcr.bazel.build/modules/rules_jvm_external/6.3/source.json": "6f5f5a5a4419ae4e37c35a5bb0a6ae657ed40b7abc5a5189111b47fcebe43197", - "https://bcr.bazel.build/modules/rules_kotlin/1.9.6/MODULE.bazel": "d269a01a18ee74d0335450b10f62c9ed81f2321d7958a2934e44272fe82dcef3", - "https://bcr.bazel.build/modules/rules_kotlin/1.9.6/source.json": "2faa4794364282db7c06600b7e5e34867a564ae91bda7cae7c29c64e9466b7d5", - "https://bcr.bazel.build/modules/rules_license/0.0.3/MODULE.bazel": "627e9ab0247f7d1e05736b59dbb1b6871373de5ad31c3011880b4133cafd4bd0", - "https://bcr.bazel.build/modules/rules_license/0.0.4/MODULE.bazel": "6a88dd22800cf1f9f79ba32cacad0d3a423ed28efa2c2ed5582eaa78dd3ac1e5", - "https://bcr.bazel.build/modules/rules_license/0.0.7/MODULE.bazel": "088fbeb0b6a419005b89cf93fe62d9517c0a2b8bb56af3244af65ecfe37e7d5d", - "https://bcr.bazel.build/modules/rules_license/1.0.0/MODULE.bazel": "a7fda60eefdf3d8c827262ba499957e4df06f659330bbe6cdbdb975b768bb65c", - "https://bcr.bazel.build/modules/rules_license/1.0.0/source.json": "a52c89e54cc311196e478f8382df91c15f7a2bfdf4c6cd0e2675cc2ff0b56efb", - "https://bcr.bazel.build/modules/rules_multirun/0.9.0/MODULE.bazel": "32d628ef586b5b23f67e55886b7bc38913ea4160420d66ae90521dda2ff37df0", - "https://bcr.bazel.build/modules/rules_multirun/0.9.0/source.json": "e882ba77962fa6c5fe68619e5c7d0374ec9a219fb8d03c42eadaf6d0243771bd", - "https://bcr.bazel.build/modules/rules_pkg/0.7.0/MODULE.bazel": "df99f03fc7934a4737122518bb87e667e62d780b610910f0447665a7e2be62dc", - "https://bcr.bazel.build/modules/rules_pkg/1.0.1/MODULE.bazel": "5b1df97dbc29623bccdf2b0dcd0f5cb08e2f2c9050aab1092fd39a41e82686ff", - "https://bcr.bazel.build/modules/rules_pkg/1.0.1/source.json": "bd82e5d7b9ce2d31e380dd9f50c111d678c3bdaca190cb76b0e1c71b05e1ba8a", - "https://bcr.bazel.build/modules/rules_proto/4.0.0/MODULE.bazel": "a7a7b6ce9bee418c1a760b3d84f83a299ad6952f9903c67f19e4edd964894e06", - "https://bcr.bazel.build/modules/rules_proto/5.3.0-21.7/MODULE.bazel": "e8dff86b0971688790ae75528fe1813f71809b5afd57facb44dad9e8eca631b7", - "https://bcr.bazel.build/modules/rules_proto/6.0.0/MODULE.bazel": "b531d7f09f58dce456cd61b4579ce8c86b38544da75184eadaf0a7cb7966453f", - "https://bcr.bazel.build/modules/rules_proto/6.0.2/MODULE.bazel": "ce916b775a62b90b61888052a416ccdda405212b6aaeb39522f7dc53431a5e73", - "https://bcr.bazel.build/modules/rules_proto/7.0.2/MODULE.bazel": "bf81793bd6d2ad89a37a40693e56c61b0ee30f7a7fdbaf3eabbf5f39de47dea2", - "https://bcr.bazel.build/modules/rules_proto/7.0.2/source.json": "1e5e7260ae32ef4f2b52fd1d0de8d03b606a44c91b694d2f1afb1d3b28a48ce1", - "https://bcr.bazel.build/modules/rules_shell/0.2.0/MODULE.bazel": "fda8a652ab3c7d8fee214de05e7a9916d8b28082234e8d2c0094505c5268ed3c", - "https://bcr.bazel.build/modules/rules_shell/0.3.0/MODULE.bazel": "de4402cd12f4cc8fda2354fce179fdb068c0b9ca1ec2d2b17b3e21b24c1a937b", - "https://bcr.bazel.build/modules/rules_shell/0.3.0/source.json": "c55ed591aa5009401ddf80ded9762ac32c358d2517ee7820be981e2de9756cf3", - "https://bcr.bazel.build/modules/rules_testing/0.6.0/MODULE.bazel": "8518d53bc742c462536d3f1a0de0c265bd7b51f32797fea4132007223ed2926f", - "https://bcr.bazel.build/modules/rules_testing/0.6.0/source.json": "915ae13ae2247c986cc57289f21e7f1d9711cd2ecfdf5867b51dc0484f3b043b", - "https://bcr.bazel.build/modules/stardoc/0.5.1/MODULE.bazel": "1a05d92974d0c122f5ccf09291442580317cdd859f07a8655f1db9a60374f9f8", - "https://bcr.bazel.build/modules/stardoc/0.5.3/MODULE.bazel": "c7f6948dae6999bf0db32c1858ae345f112cacf98f174c7a8bb707e41b974f1c", - "https://bcr.bazel.build/modules/stardoc/0.5.6/MODULE.bazel": "c43dabc564990eeab55e25ed61c07a1aadafe9ece96a4efabb3f8bf9063b71ef", - "https://bcr.bazel.build/modules/stardoc/0.7.0/MODULE.bazel": "05e3d6d30c099b6770e97da986c53bd31844d7f13d41412480ea265ac9e8079c", - "https://bcr.bazel.build/modules/stardoc/0.7.2/MODULE.bazel": "fc152419aa2ea0f51c29583fab1e8c99ddefd5b3778421845606ee628629e0e5", - "https://bcr.bazel.build/modules/stardoc/0.7.2/source.json": "58b029e5e901d6802967754adf0a9056747e8176f017cfe3607c0851f4d42216", - "https://bcr.bazel.build/modules/upb/0.0.0-20220923-a547704/MODULE.bazel": "7298990c00040a0e2f121f6c32544bab27d4452f80d9ce51349b1a28f3005c43", - "https://bcr.bazel.build/modules/zlib/1.2.11/MODULE.bazel": "07b389abc85fdbca459b69e2ec656ae5622873af3f845e1c9d80fe179f3effa0", - "https://bcr.bazel.build/modules/zlib/1.2.12/MODULE.bazel": "3b1a8834ada2a883674be8cbd36ede1b6ec481477ada359cd2d3ddc562340b27", - "https://bcr.bazel.build/modules/zlib/1.3.1.bcr.3/MODULE.bazel": "af322bc08976524477c79d1e45e241b6efbeb918c497e8840b8ab116802dda79", - "https://bcr.bazel.build/modules/zlib/1.3.1.bcr.3/source.json": "2be409ac3c7601245958cd4fcdff4288be79ed23bd690b4b951f500d54ee6e7d", - "https://bcr.bazel.build/modules/zlib/1.3.1/MODULE.bazel": "751c9940dcfe869f5f7274e1295422a34623555916eb98c174c1e945594bf198" - }, - "selectedYankedVersions": {}, - "moduleExtensions": { - "//python/extensions:pip.bzl%pip": { - "general": { - "bzlTransitiveDigest": "1N+DRsUmU5BVyzMyxa/+9ITJ8X7fWEnWTCnW4LOMmpg=", - "usagesDigest": "YlSFe2ItKSPNZPX8lwGeHExgU3q/r1fVYnFieVD4qmQ=", - "recordedFileInputs": { - "@@//docs/requirements.txt": "4b7f6f5e699049343db70f8bda0c2b97be9fd9b1b3c117a2b624dc633ba944a5", - "@@//examples/wheel/requirements_server.txt": "981e09e454aa31d72f73f369436fce488e5a478717a8fac808412f4695e44823", - "@@//tools/publish/requirements_darwin.txt": "095d4a4f3d639dce831cd493367631cd51b53665292ab20194bac2c0c6458fa8", - "@@//tools/publish/requirements_linux.txt": "d576e0d8542df61396a9b38deeaa183c24135ed5e8e73bb9622f298f2671811e", - "@@//tools/publish/requirements_windows.txt": "d18538a3982beab378fd5687f4db33162ee1ece69801f9a451661b1b64286b76", - "@@protobuf+//python/requirements.txt": "983be60d3cec4b319dcab6d48aeb3f5b2f7c3350f26b3a9e97486c37967c73c5", - "@@rules_fuzzing+//fuzzing/requirements.txt": "ab04664be026b632a0d2a2446c4f65982b7654f5b6851d2f9d399a19b7242a5b" - }, - "recordedDirentsInputs": {}, - "envVariables": { - "RULES_PYTHON_REPO_DEBUG": null, - "RULES_PYTHON_REPO_DEBUG_VERBOSITY": null - }, - "generatedRepoSpecs": { - "dev_pip_311_absl_py_py3_none_any_526a04ea": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "absl_py-2.1.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "absl-py==2.1.0", - "sha256": "526a04eadab8b4ee719ce68f204172ead1027549089702d99b9059f129ff1308", - "urls": [ - "https://files.pythonhosted.org/packages/a2/ad/e0d3c824784ff121c03cc031f944bc7e139a8f1870ffd2845cc2dd76f6c4/absl_py-2.1.0-py3-none-any.whl" - ] - } - }, - "dev_pip_311_alabaster_py3_none_any_fc678640": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "alabaster-1.0.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "alabaster==1.0.0", - "sha256": "fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", - "urls": [ - "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl" - ] - } - }, - "dev_pip_311_astroid_py3_none_any_db676dc4": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "astroid-3.3.6-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "astroid==3.3.6", - "sha256": "db676dc4f3ae6bfe31cda227dc60e03438378d7a896aec57422c95634e8d722f", - "urls": [ - "https://files.pythonhosted.org/packages/0c/d2/82c8ccef22ea873a2b0da9636e47d45137eeeb2fb9320c5dbbdd3627bab0/astroid-3.3.6-py3-none-any.whl" - ] - } - }, - "dev_pip_311_babel_py3_none_any_368b5b98": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "babel-2.16.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "babel==2.16.0", - "sha256": "368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b", - "urls": [ - "https://files.pythonhosted.org/packages/ed/20/bc79bc575ba2e2a7f70e8a1155618bb1301eaa5132a8271373a6903f73f8/babel-2.16.0-py3-none-any.whl" - ] - } - }, - "dev_pip_311_certifi_py3_none_any_922820b5": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "certifi-2024.8.30-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "certifi==2024.8.30", - "sha256": "922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8", - "urls": [ - "https://files.pythonhosted.org/packages/12/90/3c9ff0512038035f59d279fddeb79f5f1eccd8859f06d6163c58798b9487/certifi-2024.8.30-py3-none-any.whl" - ] - } - }, - "dev_pip_311_charset_normalizer_cp311_cp311_macosx_10_9_universal2_0d99dd8f": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "0d99dd8ff461990f12d6e42c7347fd9ab2532fb70e9621ba520f9e8637161d7c", - "urls": [ - "https://files.pythonhosted.org/packages/9c/61/73589dcc7a719582bf56aae309b6103d2762b526bffe189d635a7fcfd998/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl" - ] - } - }, - "dev_pip_311_charset_normalizer_cp311_cp311_macosx_10_9_x86_64_c57516e5": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "c57516e58fd17d03ebe67e181a4e4e2ccab1168f8c2976c6a334d4f819fe5944", - "urls": [ - "https://files.pythonhosted.org/packages/77/d5/8c982d58144de49f59571f940e329ad6e8615e1e82ef84584c5eeb5e1d72/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl" - ] - } - }, - "dev_pip_311_charset_normalizer_cp311_cp311_macosx_11_0_arm64_6dba5d19": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "6dba5d19c4dfab08e58d5b36304b3f92f3bd5d42c1a3fa37b5ba5cdf6dfcbcee", - "urls": [ - "https://files.pythonhosted.org/packages/bf/19/411a64f01ee971bed3231111b69eb56f9331a769072de479eae7de52296d/charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl" - ] - } - }, - "dev_pip_311_charset_normalizer_cp311_cp311_manylinux_2_17_aarch64_bf4475b8": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "bf4475b82be41b07cc5e5ff94810e6a01f276e37c2d55571e3fe175e467a1a1c", - "urls": [ - "https://files.pythonhosted.org/packages/4c/92/97509850f0d00e9f14a46bc751daabd0ad7765cff29cdfb66c68b6dad57f/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" - ] - } - }, - "dev_pip_311_charset_normalizer_cp311_cp311_manylinux_2_17_ppc64le_ce031db0": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "ce031db0408e487fd2775d745ce30a7cd2923667cf3b69d48d219f1d8f5ddeb6", - "urls": [ - "https://files.pythonhosted.org/packages/e2/29/d227805bff72ed6d6cb1ce08eec707f7cfbd9868044893617eb331f16295/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl" - ] - } - }, - "dev_pip_311_charset_normalizer_cp311_cp311_manylinux_2_17_s390x_8ff4e7cd": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "8ff4e7cdfdb1ab5698e675ca622e72d58a6fa2a8aa58195de0c0061288e6e3ea", - "urls": [ - "https://files.pythonhosted.org/packages/13/bc/87c2c9f2c144bedfa62f894c3007cd4530ba4b5351acb10dc786428a50f0/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl" - ] - } - }, - "dev_pip_311_charset_normalizer_cp311_cp311_manylinux_2_17_x86_64_3710a975": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "3710a9751938947e6327ea9f3ea6332a09bf0ba0c09cae9cb1f250bd1f1549bc", - "urls": [ - "https://files.pythonhosted.org/packages/eb/5b/6f10bad0f6461fa272bfbbdf5d0023b5fb9bc6217c92bf068fa5a99820f5/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" - ] - } - }, - "dev_pip_311_charset_normalizer_cp311_cp311_musllinux_1_2_aarch64_47334db7": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "47334db71978b23ebcf3c0f9f5ee98b8d65992b65c9c4f2d34c2eaf5bcaf0594", - "urls": [ - "https://files.pythonhosted.org/packages/d7/a1/493919799446464ed0299c8eef3c3fad0daf1c3cd48bff9263c731b0d9e2/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl" - ] - } - }, - "dev_pip_311_charset_normalizer_cp311_cp311_musllinux_1_2_ppc64le_f1a2f519": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "f1a2f519ae173b5b6a2c9d5fa3116ce16e48b3462c8b96dfdded11055e3d6365", - "urls": [ - "https://files.pythonhosted.org/packages/75/d2/0ab54463d3410709c09266dfb416d032a08f97fd7d60e94b8c6ef54ae14b/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl" - ] - } - }, - "dev_pip_311_charset_normalizer_cp311_cp311_musllinux_1_2_s390x_63bc5c4a": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "63bc5c4ae26e4bc6be6469943b8253c0fd4e4186c43ad46e713ea61a0ba49129", - "urls": [ - "https://files.pythonhosted.org/packages/8d/c9/27e41d481557be53d51e60750b85aa40eaf52b841946b3cdeff363105737/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl" - ] - } - }, - "dev_pip_311_charset_normalizer_cp311_cp311_musllinux_1_2_x86_64_bcb4f8ea": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "bcb4f8ea87d03bc51ad04add8ceaf9b0f085ac045ab4d74e73bbc2dc033f0236", - "urls": [ - "https://files.pythonhosted.org/packages/ee/44/4f62042ca8cdc0cabf87c0fc00ae27cd8b53ab68be3605ba6d071f742ad3/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl" - ] - } - }, - "dev_pip_311_charset_normalizer_cp311_cp311_win_amd64_cee4373f": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "cee4373f4d3ad28f1ab6290684d8e2ebdb9e7a1b74fdc39e4c211995f77bec27", - "urls": [ - "https://files.pythonhosted.org/packages/0b/6e/b13bd47fa9023b3699e94abf565b5a2f0b0be6e9ddac9812182596ee62e4/charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl" - ] - } - }, - "dev_pip_311_charset_normalizer_py3_none_any_fe9f97fe": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "fe9f97feb71aa9896b81973a7bbada8c49501dc73e58a10fcef6663af95e5079", - "urls": [ - "https://files.pythonhosted.org/packages/bf/9b/08c0432272d77b04803958a4598a51e2a4b51c06640af8b8f0f908c18bf2/charset_normalizer-3.4.0-py3-none-any.whl" - ] - } - }, - "dev_pip_311_colorama_py2_none_any_4f1d9991": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_windows_x86_64" - ], - "filename": "colorama-0.4.6-py2.py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "colorama==0.4.6", - "sha256": "4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", - "urls": [ - "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl" - ] - } - }, - "dev_pip_311_docutils_py3_none_any_dafca5b9": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "docutils-0.21.2-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "docutils==0.21.2", - "sha256": "dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2", - "urls": [ - "https://files.pythonhosted.org/packages/8f/d7/9322c609343d929e75e7e5e6255e614fcc67572cfd083959cdef3b7aad79/docutils-0.21.2-py3-none-any.whl" - ] - } - }, - "dev_pip_311_idna_py3_none_any_946d195a": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "idna-3.10-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "idna==3.10", - "sha256": "946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", - "urls": [ - "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl" - ] - } - }, - "dev_pip_311_imagesize_py2_none_any_0d8d18d0": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "imagesize-1.4.1-py2.py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "imagesize==1.4.1", - "sha256": "0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b", - "urls": [ - "https://files.pythonhosted.org/packages/ff/62/85c4c919272577931d407be5ba5d71c20f0b616d31a0befe0ae45bb79abd/imagesize-1.4.1-py2.py3-none-any.whl" - ] - } - }, - "dev_pip_311_jinja2_py3_none_any_bc5dd2ab": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "jinja2-3.1.4-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "jinja2==3.1.4", - "sha256": "bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d", - "urls": [ - "https://files.pythonhosted.org/packages/31/80/3a54838c3fb461f6fec263ebf3a3a41771bd05190238de3486aae8540c36/jinja2-3.1.4-py3-none-any.whl" - ] - } - }, - "dev_pip_311_markdown_it_py_py3_none_any_35521684": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "markdown_it_py-3.0.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "markdown-it-py==3.0.0", - "sha256": "355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", - "urls": [ - "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl" - ] - } - }, - "dev_pip_311_markupsafe_cp311_cp311_macosx_10_9_universal2_9025b401": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "markupsafe==3.0.2", - "sha256": "9025b4018f3a1314059769c7bf15441064b2207cb3f065e6ea1e7359cb46db9d", - "urls": [ - "https://files.pythonhosted.org/packages/6b/28/bbf83e3f76936960b850435576dd5e67034e200469571be53f69174a2dfd/MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl" - ] - } - }, - "dev_pip_311_markupsafe_cp311_cp311_macosx_11_0_arm64_93335ca3": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "markupsafe==3.0.2", - "sha256": "93335ca3812df2f366e80509ae119189886b0f3c2b81325d39efdb84a1e2ae93", - "urls": [ - "https://files.pythonhosted.org/packages/6c/30/316d194b093cde57d448a4c3209f22e3046c5bb2fb0820b118292b334be7/MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl" - ] - } - }, - "dev_pip_311_markupsafe_cp311_cp311_manylinux_2_17_aarch64_2cb8438c": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "markupsafe==3.0.2", - "sha256": "2cb8438c3cbb25e220c2ab33bb226559e7afb3baec11c4f218ffa7308603c832", - "urls": [ - "https://files.pythonhosted.org/packages/f2/96/9cdafba8445d3a53cae530aaf83c38ec64c4d5427d975c974084af5bc5d2/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" - ] - } - }, - "dev_pip_311_markupsafe_cp311_cp311_manylinux_2_17_x86_64_a123e330": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "markupsafe==3.0.2", - "sha256": "a123e330ef0853c6e822384873bef7507557d8e4a082961e1defa947aa59ba84", - "urls": [ - "https://files.pythonhosted.org/packages/f1/a4/aefb044a2cd8d7334c8a47d3fb2c9f328ac48cb349468cc31c20b539305f/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" - ] - } - }, - "dev_pip_311_markupsafe_cp311_cp311_musllinux_1_2_aarch64_d8213e09": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "markupsafe==3.0.2", - "sha256": "d8213e09c917a951de9d09ecee036d5c7d36cb6cb7dbaece4c71a60d79fb9798", - "urls": [ - "https://files.pythonhosted.org/packages/00/7b/e92c64e079b2d0d7ddf69899c98842f3f9a60a1ae72657c89ce2655c999d/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl" - ] - } - }, - "dev_pip_311_markupsafe_cp311_cp311_musllinux_1_2_x86_64_0bff5e0a": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "markupsafe==3.0.2", - "sha256": "0bff5e0ae4ef2e1ae4fdf2dfd5b76c75e5c2fa4132d05fc1b0dabcd20c7e28c4", - "urls": [ - "https://files.pythonhosted.org/packages/69/84/83439e16197337b8b14b6a5b9c2105fff81d42c2a7c5b58ac7b62ee2c3b1/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl" - ] - } - }, - "dev_pip_311_markupsafe_cp311_cp311_win_amd64_70a87b41": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "markupsafe==3.0.2", - "sha256": "70a87b411535ccad5ef2f1df5136506a10775d267e197e4cf531ced10537bd6b", - "urls": [ - "https://files.pythonhosted.org/packages/da/b8/3a3bd761922d416f3dc5d00bfbed11f66b1ab89a0c2b6e887240a30b0f6b/MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl" - ] - } - }, - "dev_pip_311_mdit_py_plugins_py3_none_any_0c673c3f": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "mdit_py_plugins-0.4.2-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "mdit-py-plugins==0.4.2", - "sha256": "0c673c3f889399a33b95e88d2f0d111b4447bdfea7f237dab2d488f459835636", - "urls": [ - "https://files.pythonhosted.org/packages/a7/f7/7782a043553ee469c1ff49cfa1cdace2d6bf99a1f333cf38676b3ddf30da/mdit_py_plugins-0.4.2-py3-none-any.whl" - ] - } - }, - "dev_pip_311_mdurl_py3_none_any_84008a41": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "mdurl-0.1.2-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "mdurl==0.1.2", - "sha256": "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", - "urls": [ - "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl" - ] - } - }, - "dev_pip_311_myst_parser_py3_none_any_b9317997": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "myst_parser-4.0.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "myst-parser==4.0.0", - "sha256": "b9317997552424448c6096c2558872fdb6f81d3ecb3a40ce84a7518798f3f28d", - "urls": [ - "https://files.pythonhosted.org/packages/ca/b4/b036f8fdb667587bb37df29dc6644681dd78b7a2a6321a34684b79412b28/myst_parser-4.0.0-py3-none-any.whl" - ] - } - }, - "dev_pip_311_packaging_py3_none_any_5b8f2217": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "packaging-24.1-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "packaging==24.1", - "sha256": "5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124", - "urls": [ - "https://files.pythonhosted.org/packages/08/aa/cc0199a5f0ad350994d660967a8efb233fe0416e4639146c089643407ce6/packaging-24.1-py3-none-any.whl" - ] - } - }, - "dev_pip_311_pygments_py3_none_any_b8e6aca0": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "pygments-2.18.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "pygments==2.18.0", - "sha256": "b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a", - "urls": [ - "https://files.pythonhosted.org/packages/f7/3f/01c8b82017c199075f8f788d0d906b9ffbbc5a47dc9918a945e13d5a2bda/pygments-2.18.0-py3-none-any.whl" - ] - } - }, - "dev_pip_311_pyyaml_cp311_cp311_macosx_10_9_x86_64_cc1c1159": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "pyyaml==6.0.2", - "sha256": "cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774", - "urls": [ - "https://files.pythonhosted.org/packages/f8/aa/7af4e81f7acba21a4c6be026da38fd2b872ca46226673c89a758ebdc4fd2/PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl" - ] - } - }, - "dev_pip_311_pyyaml_cp311_cp311_macosx_11_0_arm64_1e2120ef": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "pyyaml==6.0.2", - "sha256": "1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee", - "urls": [ - "https://files.pythonhosted.org/packages/8b/62/b9faa998fd185f65c1371643678e4d58254add437edb764a08c5a98fb986/PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl" - ] - } - }, - "dev_pip_311_pyyaml_cp311_cp311_manylinux_2_17_aarch64_5d225db5": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "pyyaml==6.0.2", - "sha256": "5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c", - "urls": [ - "https://files.pythonhosted.org/packages/ad/0c/c804f5f922a9a6563bab712d8dcc70251e8af811fce4524d57c2c0fd49a4/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" - ] - } - }, - "dev_pip_311_pyyaml_cp311_cp311_manylinux_2_17_s390x_5ac9328e": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "pyyaml==6.0.2", - "sha256": "5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317", - "urls": [ - "https://files.pythonhosted.org/packages/51/16/6af8d6a6b210c8e54f1406a6b9481febf9c64a3109c541567e35a49aa2e7/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl" - ] - } - }, - "dev_pip_311_pyyaml_cp311_cp311_manylinux_2_17_x86_64_3ad2a3de": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "pyyaml==6.0.2", - "sha256": "3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85", - "urls": [ - "https://files.pythonhosted.org/packages/75/e4/2c27590dfc9992f73aabbeb9241ae20220bd9452df27483b6e56d3975cc5/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" - ] - } - }, - "dev_pip_311_pyyaml_cp311_cp311_musllinux_1_1_aarch64_ff3824dc": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "pyyaml==6.0.2", - "sha256": "ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4", - "urls": [ - "https://files.pythonhosted.org/packages/9b/97/ecc1abf4a823f5ac61941a9c00fe501b02ac3ab0e373c3857f7d4b83e2b6/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl" - ] - } - }, - "dev_pip_311_pyyaml_cp311_cp311_musllinux_1_1_x86_64_797b4f72": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "pyyaml==6.0.2", - "sha256": "797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e", - "urls": [ - "https://files.pythonhosted.org/packages/45/73/0f49dacd6e82c9430e46f4a027baa4ca205e8b0a9dce1397f44edc23559d/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl" - ] - } - }, - "dev_pip_311_pyyaml_cp311_cp311_win_amd64_e10ce637": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "PyYAML-6.0.2-cp311-cp311-win_amd64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "pyyaml==6.0.2", - "sha256": "e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44", - "urls": [ - "https://files.pythonhosted.org/packages/ed/23/8da0bbe2ab9dcdd11f4f4557ccaf95c10b9811b13ecced089d43ce59c3c8/PyYAML-6.0.2-cp311-cp311-win_amd64.whl" - ] - } - }, - "dev_pip_311_readthedocs_sphinx_ext_py2_none_any_f8c56184": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "readthedocs_sphinx_ext-2.2.5-py2.py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "readthedocs-sphinx-ext==2.2.5", - "sha256": "f8c56184ea011c972dd45a90122568587cc85b0127bc9cf064d17c68bc809daa", - "urls": [ - "https://files.pythonhosted.org/packages/64/71/c89e7709a0d4f93af1848e9855112299a820b470d84f917b4dd5998bdd07/readthedocs_sphinx_ext-2.2.5-py2.py3-none-any.whl" - ] - } - }, - "dev_pip_311_requests_py3_none_any_70761cfe": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "requests-2.32.3-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "requests==2.32.3", - "sha256": "70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", - "urls": [ - "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl" - ] - } - }, - "dev_pip_311_snowballstemmer_py2_none_any_c8e1716e": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "snowballstemmer-2.2.0-py2.py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "snowballstemmer==2.2.0", - "sha256": "c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a", - "urls": [ - "https://files.pythonhosted.org/packages/ed/dc/c02e01294f7265e63a7315fe086dd1df7dacb9f840a804da846b96d01b96/snowballstemmer-2.2.0-py2.py3-none-any.whl" - ] - } - }, - "dev_pip_311_sphinx_autodoc2_py3_none_any_e867013b": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "sphinx_autodoc2-0.5.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "sphinx-autodoc2==0.5.0", - "sha256": "e867013b1512f9d6d7e6f6799f8b537d6884462acd118ef361f3f619a60b5c9e", - "urls": [ - "https://files.pythonhosted.org/packages/19/e6/48d47961bbdae755ba9c17dfc65d89356312c67668dcb36c87cfadfa1964/sphinx_autodoc2-0.5.0-py3-none-any.whl" - ] - } - }, - "dev_pip_311_sphinx_py3_none_any_09719015": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "sphinx-8.1.3-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "sphinx==8.1.3", - "sha256": "09719015511837b76bf6e03e42eb7595ac8c2e41eeb9c29c5b755c6b677992a2", - "urls": [ - "https://files.pythonhosted.org/packages/26/60/1ddff83a56d33aaf6f10ec8ce84b4c007d9368b21008876fceda7e7381ef/sphinx-8.1.3-py3-none-any.whl" - ] - } - }, - "dev_pip_311_sphinx_reredirects_py3_none_any_444ae143": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "sphinx_reredirects-0.1.5-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "sphinx-reredirects==0.1.5", - "sha256": "444ae1438fba4418242ca76d6a6de3eaee82aaf0d8f2b0cac71a15d32ce6eba2", - "urls": [ - "https://files.pythonhosted.org/packages/34/97/1f8143f87330f4c9ccc2c08ae9cd3cb1ce2944c51e98dd7ff141154fbcc7/sphinx_reredirects-0.1.5-py3-none-any.whl" - ] - } - }, - "dev_pip_311_sphinx_rtd_theme_py2_none_any_921c0ece": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "sphinx_rtd_theme-3.0.1-py2.py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "sphinx-rtd-theme==3.0.1", - "sha256": "921c0ece75e90633ee876bd7b148cfaad136b481907ad154ac3669b6fc957916", - "urls": [ - "https://files.pythonhosted.org/packages/c8/51/aed903ad0843a06ccfb93e6e8849e752a9379eaec0f50d9237ae373dd737/sphinx_rtd_theme-3.0.1-py2.py3-none-any.whl" - ] - } - }, - "dev_pip_311_sphinxcontrib_applehelp_py3_none_any_4cd3f0ec": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "sphinxcontrib-applehelp==2.0.0", - "sha256": "4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", - "urls": [ - "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl" - ] - } - }, - "dev_pip_311_sphinxcontrib_devhelp_py3_none_any_aefb8b83": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "sphinxcontrib-devhelp==2.0.0", - "sha256": "aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", - "urls": [ - "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl" - ] - } - }, - "dev_pip_311_sphinxcontrib_htmlhelp_py3_none_any_16675982": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "sphinxcontrib-htmlhelp==2.1.0", - "sha256": "166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", - "urls": [ - "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl" - ] - } - }, - "dev_pip_311_sphinxcontrib_jquery_py2_none_any_f936030d": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "sphinxcontrib_jquery-4.1-py2.py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "sphinxcontrib-jquery==4.1", - "sha256": "f936030d7d0147dd026a4f2b5a57343d233f1fc7b363f68b3d4f1cb0993878ae", - "urls": [ - "https://files.pythonhosted.org/packages/76/85/749bd22d1a68db7291c89e2ebca53f4306c3f205853cf31e9de279034c3c/sphinxcontrib_jquery-4.1-py2.py3-none-any.whl" - ] - } - }, - "dev_pip_311_sphinxcontrib_jsmath_py2_none_any_2ec2eaeb": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "sphinxcontrib-jsmath==1.0.1", - "sha256": "2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", - "urls": [ - "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl" - ] - } - }, - "dev_pip_311_sphinxcontrib_qthelp_py3_none_any_b18a828c": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "sphinxcontrib-qthelp==2.0.0", - "sha256": "b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", - "urls": [ - "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl" - ] - } - }, - "dev_pip_311_sphinxcontrib_serializinghtml_py3_none_any_6e2cb0ee": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "sphinxcontrib-serializinghtml==2.0.0", - "sha256": "6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", - "urls": [ - "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl" - ] - } - }, - "dev_pip_311_typing_extensions_py3_none_any_04e5ca03": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "typing_extensions-4.12.2-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "typing-extensions==4.12.2", - "sha256": "04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", - "urls": [ - "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl" - ] - } - }, - "dev_pip_311_urllib3_py3_none_any_ca899ca0": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "urllib3-2.2.3-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "dev_pip_311", - "requirement": "urllib3==2.2.3", - "sha256": "ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac", - "urls": [ - "https://files.pythonhosted.org/packages/ce/d9/5f4c13cecde62396b0d3fe530a50ccea91e7dfc1ccf0e09c228841bb5ba8/urllib3-2.2.3-py3-none-any.whl" - ] - } - }, - "dev_pip_313_absl_py_py3_none_any_526a04ea": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "absl_py-2.1.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "absl-py==2.1.0", - "sha256": "526a04eadab8b4ee719ce68f204172ead1027549089702d99b9059f129ff1308", - "urls": [ - "https://files.pythonhosted.org/packages/a2/ad/e0d3c824784ff121c03cc031f944bc7e139a8f1870ffd2845cc2dd76f6c4/absl_py-2.1.0-py3-none-any.whl" - ] - } - }, - "dev_pip_313_alabaster_py3_none_any_fc678640": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "alabaster-1.0.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "alabaster==1.0.0", - "sha256": "fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", - "urls": [ - "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl" - ] - } - }, - "dev_pip_313_astroid_py3_none_any_db676dc4": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "astroid-3.3.6-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "astroid==3.3.6", - "sha256": "db676dc4f3ae6bfe31cda227dc60e03438378d7a896aec57422c95634e8d722f", - "urls": [ - "https://files.pythonhosted.org/packages/0c/d2/82c8ccef22ea873a2b0da9636e47d45137eeeb2fb9320c5dbbdd3627bab0/astroid-3.3.6-py3-none-any.whl" - ] - } - }, - "dev_pip_313_babel_py3_none_any_368b5b98": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "babel-2.16.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "babel==2.16.0", - "sha256": "368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b", - "urls": [ - "https://files.pythonhosted.org/packages/ed/20/bc79bc575ba2e2a7f70e8a1155618bb1301eaa5132a8271373a6903f73f8/babel-2.16.0-py3-none-any.whl" - ] - } - }, - "dev_pip_313_certifi_py3_none_any_922820b5": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "certifi-2024.8.30-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "certifi==2024.8.30", - "sha256": "922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8", - "urls": [ - "https://files.pythonhosted.org/packages/12/90/3c9ff0512038035f59d279fddeb79f5f1eccd8859f06d6163c58798b9487/certifi-2024.8.30-py3-none-any.whl" - ] - } - }, - "dev_pip_313_charset_normalizer_cp313_cp313_macosx_10_13_universal2_dd4eda17": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_universal2.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "charset-normalizer==3.4.0", - "sha256": "dd4eda173a9fcccb5f2e2bd2a9f423d180194b1bf17cf59e3269899235b2a114", - "urls": [ - "https://files.pythonhosted.org/packages/f3/89/68a4c86f1a0002810a27f12e9a7b22feb198c59b2f05231349fbce5c06f4/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_universal2.whl" - ] - } - }, - "dev_pip_313_charset_normalizer_cp313_cp313_macosx_10_13_x86_64_e9e3c4c9": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "charset-normalizer==3.4.0", - "sha256": "e9e3c4c9e1ed40ea53acf11e2a386383c3304212c965773704e4603d589343ed", - "urls": [ - "https://files.pythonhosted.org/packages/4f/cd/8947fe425e2ab0aa57aceb7807af13a0e4162cd21eee42ef5b053447edf5/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_x86_64.whl" - ] - } - }, - "dev_pip_313_charset_normalizer_cp313_cp313_macosx_11_0_arm64_92a7e36b": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp313-cp313-macosx_11_0_arm64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "charset-normalizer==3.4.0", - "sha256": "92a7e36b000bf022ef3dbb9c46bfe2d52c047d5e3f3343f43204263c5addc250", - "urls": [ - "https://files.pythonhosted.org/packages/5b/f0/b5263e8668a4ee9becc2b451ed909e9c27058337fda5b8c49588183c267a/charset_normalizer-3.4.0-cp313-cp313-macosx_11_0_arm64.whl" - ] - } - }, - "dev_pip_313_charset_normalizer_cp313_cp313_manylinux_2_17_aarch64_54b6a92d": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "charset-normalizer==3.4.0", - "sha256": "54b6a92d009cbe2fb11054ba694bc9e284dad30a26757b1e372a1fdddaf21920", - "urls": [ - "https://files.pythonhosted.org/packages/ff/6e/e445afe4f7fda27a533f3234b627b3e515a1b9429bc981c9a5e2aa5d97b6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" - ] - } - }, - "dev_pip_313_charset_normalizer_cp313_cp313_manylinux_2_17_ppc64le_1ffd9493": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "charset-normalizer==3.4.0", - "sha256": "1ffd9493de4c922f2a38c2bf62b831dcec90ac673ed1ca182fe11b4d8e9f2a64", - "urls": [ - "https://files.pythonhosted.org/packages/a1/b2/4af9993b532d93270538ad4926c8e37dc29f2111c36f9c629840c57cd9b3/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl" - ] - } - }, - "dev_pip_313_charset_normalizer_cp313_cp313_manylinux_2_17_s390x_35c404d7": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "charset-normalizer==3.4.0", - "sha256": "35c404d74c2926d0287fbd63ed5d27eb911eb9e4a3bb2c6d294f3cfd4a9e0c23", - "urls": [ - "https://files.pythonhosted.org/packages/fb/6f/4e78c3b97686b871db9be6f31d64e9264e889f8c9d7ab33c771f847f79b7/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl" - ] - } - }, - "dev_pip_313_charset_normalizer_cp313_cp313_manylinux_2_17_x86_64_4796efc4": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "charset-normalizer==3.4.0", - "sha256": "4796efc4faf6b53a18e3d46343535caed491776a22af773f366534056c4e1fbc", - "urls": [ - "https://files.pythonhosted.org/packages/2b/c9/1c8fe3ce05d30c87eff498592c89015b19fade13df42850aafae09e94f35/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" - ] - } - }, - "dev_pip_313_charset_normalizer_cp313_cp313_musllinux_1_2_aarch64_92db3c28": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "charset-normalizer==3.4.0", - "sha256": "92db3c28b5b2a273346bebb24857fda45601aef6ae1c011c0a997106581e8a88", - "urls": [ - "https://files.pythonhosted.org/packages/0c/75/1ed813c3ffd200b1f3e71121c95da3f79e6d2a96120163443b3ad1057505/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_aarch64.whl" - ] - } - }, - "dev_pip_313_charset_normalizer_cp313_cp313_musllinux_1_2_ppc64le_4b67fdab": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "charset-normalizer==3.4.0", - "sha256": "4b67fdab07fdd3c10bb21edab3cbfe8cf5696f453afce75d815d9d7223fbe88b", - "urls": [ - "https://files.pythonhosted.org/packages/ac/a0/c1b5298de4670d997101fef95b97ac440e8c8d8b4efa5a4d1ef44af82f0d/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl" - ] - } - }, - "dev_pip_313_charset_normalizer_cp313_cp313_musllinux_1_2_s390x_aa41e526": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_s390x.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "charset-normalizer==3.4.0", - "sha256": "aa41e526a5d4a9dfcfbab0716c7e8a1b215abd3f3df5a45cf18a12721d31cb5d", - "urls": [ - "https://files.pythonhosted.org/packages/04/4f/b3961ba0c664989ba63e30595a3ed0875d6790ff26671e2aae2fdc28a399/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_s390x.whl" - ] - } - }, - "dev_pip_313_charset_normalizer_cp313_cp313_musllinux_1_2_x86_64_ffc51962": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "charset-normalizer==3.4.0", - "sha256": "ffc519621dce0c767e96b9c53f09c5d215578e10b02c285809f76509a3931482", - "urls": [ - "https://files.pythonhosted.org/packages/d8/90/6af4cd042066a4adad58ae25648a12c09c879efa4849c705719ba1b23d8c/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_x86_64.whl" - ] - } - }, - "dev_pip_313_charset_normalizer_cp313_cp313_win_amd64_707b82d1": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp313-cp313-win_amd64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "charset-normalizer==3.4.0", - "sha256": "707b82d19e65c9bd28b81dde95249b07bf9f5b90ebe1ef17d9b57473f8a64b7b", - "urls": [ - "https://files.pythonhosted.org/packages/65/97/fc9bbc54ee13d33dc54a7fcf17b26368b18505500fc01e228c27b5222d80/charset_normalizer-3.4.0-cp313-cp313-win_amd64.whl" - ] - } - }, - "dev_pip_313_charset_normalizer_py3_none_any_fe9f97fe": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "charset-normalizer==3.4.0", - "sha256": "fe9f97feb71aa9896b81973a7bbada8c49501dc73e58a10fcef6663af95e5079", - "urls": [ - "https://files.pythonhosted.org/packages/bf/9b/08c0432272d77b04803958a4598a51e2a4b51c06640af8b8f0f908c18bf2/charset_normalizer-3.4.0-py3-none-any.whl" - ] - } - }, - "dev_pip_313_colorama_py2_none_any_4f1d9991": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_windows_x86_64" - ], - "filename": "colorama-0.4.6-py2.py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "colorama==0.4.6", - "sha256": "4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", - "urls": [ - "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl" - ] - } - }, - "dev_pip_313_docutils_py3_none_any_dafca5b9": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "docutils-0.21.2-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "docutils==0.21.2", - "sha256": "dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2", - "urls": [ - "https://files.pythonhosted.org/packages/8f/d7/9322c609343d929e75e7e5e6255e614fcc67572cfd083959cdef3b7aad79/docutils-0.21.2-py3-none-any.whl" - ] - } - }, - "dev_pip_313_idna_py3_none_any_946d195a": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "idna-3.10-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "idna==3.10", - "sha256": "946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", - "urls": [ - "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl" - ] - } - }, - "dev_pip_313_imagesize_py2_none_any_0d8d18d0": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "imagesize-1.4.1-py2.py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "imagesize==1.4.1", - "sha256": "0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b", - "urls": [ - "https://files.pythonhosted.org/packages/ff/62/85c4c919272577931d407be5ba5d71c20f0b616d31a0befe0ae45bb79abd/imagesize-1.4.1-py2.py3-none-any.whl" - ] - } - }, - "dev_pip_313_jinja2_py3_none_any_bc5dd2ab": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "jinja2-3.1.4-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "jinja2==3.1.4", - "sha256": "bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d", - "urls": [ - "https://files.pythonhosted.org/packages/31/80/3a54838c3fb461f6fec263ebf3a3a41771bd05190238de3486aae8540c36/jinja2-3.1.4-py3-none-any.whl" - ] - } - }, - "dev_pip_313_markdown_it_py_py3_none_any_35521684": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "markdown_it_py-3.0.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "markdown-it-py==3.0.0", - "sha256": "355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", - "urls": [ - "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl" - ] - } - }, - "dev_pip_313_markupsafe_cp313_cp313_macosx_10_13_universal2_ba9527cd": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "markupsafe==3.0.2", - "sha256": "ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd", - "urls": [ - "https://files.pythonhosted.org/packages/83/0e/67eb10a7ecc77a0c2bbe2b0235765b98d164d81600746914bebada795e97/MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl" - ] - } - }, - "dev_pip_313_markupsafe_cp313_cp313_macosx_11_0_arm64_f8b3d067": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "markupsafe==3.0.2", - "sha256": "f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430", - "urls": [ - "https://files.pythonhosted.org/packages/2b/6d/9409f3684d3335375d04e5f05744dfe7e9f120062c9857df4ab490a1031a/MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl" - ] - } - }, - "dev_pip_313_markupsafe_cp313_cp313_manylinux_2_17_aarch64_569511d3": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "markupsafe==3.0.2", - "sha256": "569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094", - "urls": [ - "https://files.pythonhosted.org/packages/d2/f5/6eadfcd3885ea85fe2a7c128315cc1bb7241e1987443d78c8fe712d03091/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" - ] - } - }, - "dev_pip_313_markupsafe_cp313_cp313_manylinux_2_17_x86_64_15ab75ef": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "markupsafe==3.0.2", - "sha256": "15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396", - "urls": [ - "https://files.pythonhosted.org/packages/0c/91/96cf928db8236f1bfab6ce15ad070dfdd02ed88261c2afafd4b43575e9e9/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" - ] - } - }, - "dev_pip_313_markupsafe_cp313_cp313_musllinux_1_2_aarch64_cdb82a87": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "markupsafe==3.0.2", - "sha256": "cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a", - "urls": [ - "https://files.pythonhosted.org/packages/2a/9f/8619835cd6a711d6272d62abb78c033bda638fdc54c4e7f4272cf1c0962b/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl" - ] - } - }, - "dev_pip_313_markupsafe_cp313_cp313_musllinux_1_2_x86_64_444dcda7": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "markupsafe==3.0.2", - "sha256": "444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c", - "urls": [ - "https://files.pythonhosted.org/packages/ce/4f/9a02c1d335caabe5c4efb90e1b6e8ee944aa245c1aaaab8e8a618987d816/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl" - ] - } - }, - "dev_pip_313_markupsafe_cp313_cp313_win_amd64_e6a2a455": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "markupsafe==3.0.2", - "sha256": "e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f", - "urls": [ - "https://files.pythonhosted.org/packages/29/88/07df22d2dd4df40aba9f3e402e6dc1b8ee86297dddbad4872bd5e7b0094f/MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl" - ] - } - }, - "dev_pip_313_markupsafe_cp313_cp313t_macosx_10_13_universal2_b5a6b3ad": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "markupsafe==3.0.2", - "sha256": "b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c", - "urls": [ - "https://files.pythonhosted.org/packages/62/6a/8b89d24db2d32d433dffcd6a8779159da109842434f1dd2f6e71f32f738c/MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl" - ] - } - }, - "dev_pip_313_markupsafe_cp313_cp313t_macosx_11_0_arm64_a904af0a": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "markupsafe==3.0.2", - "sha256": "a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb", - "urls": [ - "https://files.pythonhosted.org/packages/7a/06/a10f955f70a2e5a9bf78d11a161029d278eeacbd35ef806c3fd17b13060d/MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl" - ] - } - }, - "dev_pip_313_markupsafe_cp313_cp313t_manylinux_2_17_aarch64_4aa4e5fa": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "markupsafe==3.0.2", - "sha256": "4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c", - "urls": [ - "https://files.pythonhosted.org/packages/34/cf/65d4a571869a1a9078198ca28f39fba5fbb910f952f9dbc5220afff9f5e6/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" - ] - } - }, - "dev_pip_313_markupsafe_cp313_cp313t_manylinux_2_17_x86_64_c0ef13ea": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "markupsafe==3.0.2", - "sha256": "c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d", - "urls": [ - "https://files.pythonhosted.org/packages/0c/e3/90e9651924c430b885468b56b3d597cabf6d72be4b24a0acd1fa0e12af67/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" - ] - } - }, - "dev_pip_313_markupsafe_cp313_cp313t_musllinux_1_2_aarch64_6381026f": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "markupsafe==3.0.2", - "sha256": "6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5", - "urls": [ - "https://files.pythonhosted.org/packages/bb/35/cbe9238ec3f47ac9a7c8b3df7a808e7cb50fe149dc7039f5f454b3fba218/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl" - ] - } - }, - "dev_pip_313_markupsafe_cp313_cp313t_musllinux_1_2_x86_64_131a3c76": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "markupsafe==3.0.2", - "sha256": "131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9", - "urls": [ - "https://files.pythonhosted.org/packages/0d/80/0985960e4b89922cb5a0bac0ed39c5b96cbc1a536a99f30e8c220a996ed9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl" - ] - } - }, - "dev_pip_313_markupsafe_cp313_cp313t_win_amd64_e444a31f": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "markupsafe==3.0.2", - "sha256": "e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", - "urls": [ - "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl" - ] - } - }, - "dev_pip_313_mdit_py_plugins_py3_none_any_0c673c3f": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "mdit_py_plugins-0.4.2-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "mdit-py-plugins==0.4.2", - "sha256": "0c673c3f889399a33b95e88d2f0d111b4447bdfea7f237dab2d488f459835636", - "urls": [ - "https://files.pythonhosted.org/packages/a7/f7/7782a043553ee469c1ff49cfa1cdace2d6bf99a1f333cf38676b3ddf30da/mdit_py_plugins-0.4.2-py3-none-any.whl" - ] - } - }, - "dev_pip_313_mdurl_py3_none_any_84008a41": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "mdurl-0.1.2-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "mdurl==0.1.2", - "sha256": "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", - "urls": [ - "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl" - ] - } - }, - "dev_pip_313_myst_parser_py3_none_any_b9317997": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "myst_parser-4.0.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "myst-parser==4.0.0", - "sha256": "b9317997552424448c6096c2558872fdb6f81d3ecb3a40ce84a7518798f3f28d", - "urls": [ - "https://files.pythonhosted.org/packages/ca/b4/b036f8fdb667587bb37df29dc6644681dd78b7a2a6321a34684b79412b28/myst_parser-4.0.0-py3-none-any.whl" - ] - } - }, - "dev_pip_313_packaging_py3_none_any_5b8f2217": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "packaging-24.1-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "packaging==24.1", - "sha256": "5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124", - "urls": [ - "https://files.pythonhosted.org/packages/08/aa/cc0199a5f0ad350994d660967a8efb233fe0416e4639146c089643407ce6/packaging-24.1-py3-none-any.whl" - ] - } - }, - "dev_pip_313_pygments_py3_none_any_b8e6aca0": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "pygments-2.18.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "pygments==2.18.0", - "sha256": "b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a", - "urls": [ - "https://files.pythonhosted.org/packages/f7/3f/01c8b82017c199075f8f788d0d906b9ffbbc5a47dc9918a945e13d5a2bda/pygments-2.18.0-py3-none-any.whl" - ] - } - }, - "dev_pip_313_pyyaml_cp313_cp313_macosx_10_13_x86_64_efdca563": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "pyyaml==6.0.2", - "sha256": "efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", - "urls": [ - "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl" - ] - } - }, - "dev_pip_313_pyyaml_cp313_cp313_macosx_11_0_arm64_50187695": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "pyyaml==6.0.2", - "sha256": "50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", - "urls": [ - "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl" - ] - } - }, - "dev_pip_313_pyyaml_cp313_cp313_manylinux_2_17_aarch64_0ffe8360": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "pyyaml==6.0.2", - "sha256": "0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", - "urls": [ - "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" - ] - } - }, - "dev_pip_313_pyyaml_cp313_cp313_manylinux_2_17_s390x_17e311b6": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "pyyaml==6.0.2", - "sha256": "17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", - "urls": [ - "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl" - ] - } - }, - "dev_pip_313_pyyaml_cp313_cp313_manylinux_2_17_x86_64_70b18959": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "pyyaml==6.0.2", - "sha256": "70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", - "urls": [ - "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" - ] - } - }, - "dev_pip_313_pyyaml_cp313_cp313_musllinux_1_1_aarch64_41e4e395": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "pyyaml==6.0.2", - "sha256": "41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", - "urls": [ - "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl" - ] - } - }, - "dev_pip_313_pyyaml_cp313_cp313_musllinux_1_1_x86_64_68ccc602": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "pyyaml==6.0.2", - "sha256": "68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", - "urls": [ - "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl" - ] - } - }, - "dev_pip_313_pyyaml_cp313_cp313_win_amd64_8388ee19": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "PyYAML-6.0.2-cp313-cp313-win_amd64.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "pyyaml==6.0.2", - "sha256": "8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", - "urls": [ - "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl" - ] - } - }, - "dev_pip_313_readthedocs_sphinx_ext_py2_none_any_f8c56184": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "readthedocs_sphinx_ext-2.2.5-py2.py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "readthedocs-sphinx-ext==2.2.5", - "sha256": "f8c56184ea011c972dd45a90122568587cc85b0127bc9cf064d17c68bc809daa", - "urls": [ - "https://files.pythonhosted.org/packages/64/71/c89e7709a0d4f93af1848e9855112299a820b470d84f917b4dd5998bdd07/readthedocs_sphinx_ext-2.2.5-py2.py3-none-any.whl" - ] - } - }, - "dev_pip_313_requests_py3_none_any_70761cfe": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "requests-2.32.3-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "requests==2.32.3", - "sha256": "70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", - "urls": [ - "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl" - ] - } - }, - "dev_pip_313_snowballstemmer_py2_none_any_c8e1716e": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "snowballstemmer-2.2.0-py2.py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "snowballstemmer==2.2.0", - "sha256": "c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a", - "urls": [ - "https://files.pythonhosted.org/packages/ed/dc/c02e01294f7265e63a7315fe086dd1df7dacb9f840a804da846b96d01b96/snowballstemmer-2.2.0-py2.py3-none-any.whl" - ] - } - }, - "dev_pip_313_sphinx_autodoc2_py3_none_any_e867013b": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "sphinx_autodoc2-0.5.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "sphinx-autodoc2==0.5.0", - "sha256": "e867013b1512f9d6d7e6f6799f8b537d6884462acd118ef361f3f619a60b5c9e", - "urls": [ - "https://files.pythonhosted.org/packages/19/e6/48d47961bbdae755ba9c17dfc65d89356312c67668dcb36c87cfadfa1964/sphinx_autodoc2-0.5.0-py3-none-any.whl" - ] - } - }, - "dev_pip_313_sphinx_py3_none_any_09719015": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "sphinx-8.1.3-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "sphinx==8.1.3", - "sha256": "09719015511837b76bf6e03e42eb7595ac8c2e41eeb9c29c5b755c6b677992a2", - "urls": [ - "https://files.pythonhosted.org/packages/26/60/1ddff83a56d33aaf6f10ec8ce84b4c007d9368b21008876fceda7e7381ef/sphinx-8.1.3-py3-none-any.whl" - ] - } - }, - "dev_pip_313_sphinx_reredirects_py3_none_any_444ae143": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "sphinx_reredirects-0.1.5-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "sphinx-reredirects==0.1.5", - "sha256": "444ae1438fba4418242ca76d6a6de3eaee82aaf0d8f2b0cac71a15d32ce6eba2", - "urls": [ - "https://files.pythonhosted.org/packages/34/97/1f8143f87330f4c9ccc2c08ae9cd3cb1ce2944c51e98dd7ff141154fbcc7/sphinx_reredirects-0.1.5-py3-none-any.whl" - ] - } - }, - "dev_pip_313_sphinx_rtd_theme_py2_none_any_921c0ece": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "sphinx_rtd_theme-3.0.1-py2.py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "sphinx-rtd-theme==3.0.1", - "sha256": "921c0ece75e90633ee876bd7b148cfaad136b481907ad154ac3669b6fc957916", - "urls": [ - "https://files.pythonhosted.org/packages/c8/51/aed903ad0843a06ccfb93e6e8849e752a9379eaec0f50d9237ae373dd737/sphinx_rtd_theme-3.0.1-py2.py3-none-any.whl" - ] - } - }, - "dev_pip_313_sphinxcontrib_applehelp_py3_none_any_4cd3f0ec": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "sphinxcontrib-applehelp==2.0.0", - "sha256": "4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", - "urls": [ - "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl" - ] - } - }, - "dev_pip_313_sphinxcontrib_devhelp_py3_none_any_aefb8b83": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "sphinxcontrib-devhelp==2.0.0", - "sha256": "aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", - "urls": [ - "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl" - ] - } - }, - "dev_pip_313_sphinxcontrib_htmlhelp_py3_none_any_16675982": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "sphinxcontrib-htmlhelp==2.1.0", - "sha256": "166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", - "urls": [ - "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl" - ] - } - }, - "dev_pip_313_sphinxcontrib_jquery_py2_none_any_f936030d": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "sphinxcontrib_jquery-4.1-py2.py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "sphinxcontrib-jquery==4.1", - "sha256": "f936030d7d0147dd026a4f2b5a57343d233f1fc7b363f68b3d4f1cb0993878ae", - "urls": [ - "https://files.pythonhosted.org/packages/76/85/749bd22d1a68db7291c89e2ebca53f4306c3f205853cf31e9de279034c3c/sphinxcontrib_jquery-4.1-py2.py3-none-any.whl" - ] - } - }, - "dev_pip_313_sphinxcontrib_jsmath_py2_none_any_2ec2eaeb": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "sphinxcontrib-jsmath==1.0.1", - "sha256": "2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", - "urls": [ - "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl" - ] - } - }, - "dev_pip_313_sphinxcontrib_qthelp_py3_none_any_b18a828c": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "sphinxcontrib-qthelp==2.0.0", - "sha256": "b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", - "urls": [ - "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl" - ] - } - }, - "dev_pip_313_sphinxcontrib_serializinghtml_py3_none_any_6e2cb0ee": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "sphinxcontrib-serializinghtml==2.0.0", - "sha256": "6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", - "urls": [ - "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl" - ] - } - }, - "dev_pip_313_typing_extensions_py3_none_any_04e5ca03": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "typing_extensions-4.12.2-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "typing-extensions==4.12.2", - "sha256": "04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", - "urls": [ - "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl" - ] - } - }, - "dev_pip_313_urllib3_py3_none_any_ca899ca0": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@dev_pip//{name}:{target}", - "experimental_target_platforms": [ - "cp313_linux_aarch64", - "cp313_linux_arm", - "cp313_linux_ppc", - "cp313_linux_s390x", - "cp313_linux_x86_64", - "cp313_osx_aarch64", - "cp313_osx_x86_64", - "cp313_windows_x86_64" - ], - "filename": "urllib3-2.2.3-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_13_0_host//:python", - "repo": "dev_pip_313", - "requirement": "urllib3==2.2.3", - "sha256": "ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac", - "urls": [ - "https://files.pythonhosted.org/packages/ce/d9/5f4c13cecde62396b0d3fe530a50ccea91e7dfc1ccf0e09c228841bb5ba8/urllib3-2.2.3-py3-none-any.whl" - ] - } - }, - "pip_deps_310_numpy": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@pip_deps//{name}:{target}", - "python_interpreter_target": "@@+python+python_3_10_host//:python", - "repo": "pip_deps_310", - "requirement": "numpy<=1.26.1" - } - }, - "pip_deps_310_setuptools": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@pip_deps//{name}:{target}", - "python_interpreter_target": "@@+python+python_3_10_host//:python", - "repo": "pip_deps_310", - "requirement": "setuptools<=70.3.0" - } - }, - "pip_deps_311_numpy": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@pip_deps//{name}:{target}", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "pip_deps_311", - "requirement": "numpy<=1.26.1" - } - }, - "pip_deps_311_setuptools": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@pip_deps//{name}:{target}", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "pip_deps_311", - "requirement": "setuptools<=70.3.0" - } - }, - "pip_deps_312_numpy": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@pip_deps//{name}:{target}", - "python_interpreter_target": "@@+python+python_3_12_host//:python", - "repo": "pip_deps_312", - "requirement": "numpy<=1.26.1" - } - }, - "pip_deps_312_setuptools": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@pip_deps//{name}:{target}", - "python_interpreter_target": "@@+python+python_3_12_host//:python", - "repo": "pip_deps_312", - "requirement": "setuptools<=70.3.0" - } - }, - "pip_deps_38_numpy": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@pip_deps//{name}:{target}", - "python_interpreter_target": "@@+python+python_3_8_host//:python", - "repo": "pip_deps_38", - "requirement": "numpy<=1.26.1" - } - }, - "pip_deps_38_setuptools": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@pip_deps//{name}:{target}", - "python_interpreter_target": "@@+python+python_3_8_host//:python", - "repo": "pip_deps_38", - "requirement": "setuptools<=70.3.0" - } - }, - "pip_deps_39_numpy": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@pip_deps//{name}:{target}", - "python_interpreter_target": "@@+python+python_3_9_host//:python", - "repo": "pip_deps_39", - "requirement": "numpy<=1.26.1" - } - }, - "pip_deps_39_setuptools": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@pip_deps//{name}:{target}", - "python_interpreter_target": "@@+python+python_3_9_host//:python", - "repo": "pip_deps_39", - "requirement": "setuptools<=70.3.0" - } - }, - "pypiserver_311_pip_py3_none_any_ba0d021a": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@pypiserver//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "pip-24.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "pypiserver_311", - "requirement": "pip==24.0", - "sha256": "ba0d021a166865d2265246961bec0152ff124de910c5cc39f1156ce3fa7c69dc", - "urls": [ - "https://files.pythonhosted.org/packages/8a/6a/19e9fe04fca059ccf770861c7d5721ab4c2aebc539889e97c7977528a53b/pip-24.0-py3-none-any.whl" - ] - } - }, - "pypiserver_311_pypiserver_py2_none_any_1dd98fb9": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@pypiserver//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "pypiserver-2.0.1-py2.py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "pypiserver_311", - "requirement": "pypiserver==2.0.1", - "sha256": "1dd98fb99d2da4199fb44c7284e57d69a9f7fda2c6c8dc01975c151c592677bf", - "urls": [ - "https://files.pythonhosted.org/packages/34/95/6c70e2f7e8375354fd7b1db08405c93674f2e4ce4e714f379fadd06a92b1/pypiserver-2.0.1-py2.py3-none-any.whl" - ] - } - }, - "rules_fuzzing_py_deps_310_absl_py": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", - "extra_pip_args": [ - "--require-hashes" - ], - "python_interpreter_target": "@@+python+python_3_10_host//:python", - "repo": "rules_fuzzing_py_deps_310", - "requirement": "absl-py==2.0.0 --hash=sha256:9a28abb62774ae4e8edbe2dd4c49ffcd45a6a848952a5eccc6a49f3f0fc1e2f3" - } - }, - "rules_fuzzing_py_deps_310_six": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", - "extra_pip_args": [ - "--require-hashes" - ], - "python_interpreter_target": "@@+python+python_3_10_host//:python", - "repo": "rules_fuzzing_py_deps_310", - "requirement": "six==1.16.0 --hash=sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254" - } - }, - "rules_fuzzing_py_deps_311_absl_py": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", - "extra_pip_args": [ - "--require-hashes" - ], - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_fuzzing_py_deps_311", - "requirement": "absl-py==2.0.0 --hash=sha256:9a28abb62774ae4e8edbe2dd4c49ffcd45a6a848952a5eccc6a49f3f0fc1e2f3" - } - }, - "rules_fuzzing_py_deps_311_six": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", - "extra_pip_args": [ - "--require-hashes" - ], - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_fuzzing_py_deps_311", - "requirement": "six==1.16.0 --hash=sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254" - } - }, - "rules_fuzzing_py_deps_312_absl_py": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", - "extra_pip_args": [ - "--require-hashes" - ], - "python_interpreter_target": "@@+python+python_3_12_host//:python", - "repo": "rules_fuzzing_py_deps_312", - "requirement": "absl-py==2.0.0 --hash=sha256:9a28abb62774ae4e8edbe2dd4c49ffcd45a6a848952a5eccc6a49f3f0fc1e2f3" - } - }, - "rules_fuzzing_py_deps_312_six": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", - "extra_pip_args": [ - "--require-hashes" - ], - "python_interpreter_target": "@@+python+python_3_12_host//:python", - "repo": "rules_fuzzing_py_deps_312", - "requirement": "six==1.16.0 --hash=sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254" - } - }, - "rules_fuzzing_py_deps_38_absl_py": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", - "extra_pip_args": [ - "--require-hashes" - ], - "python_interpreter_target": "@@+python+python_3_8_host//:python", - "repo": "rules_fuzzing_py_deps_38", - "requirement": "absl-py==2.0.0 --hash=sha256:9a28abb62774ae4e8edbe2dd4c49ffcd45a6a848952a5eccc6a49f3f0fc1e2f3" - } - }, - "rules_fuzzing_py_deps_38_six": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", - "extra_pip_args": [ - "--require-hashes" - ], - "python_interpreter_target": "@@+python+python_3_8_host//:python", - "repo": "rules_fuzzing_py_deps_38", - "requirement": "six==1.16.0 --hash=sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254" - } - }, - "rules_fuzzing_py_deps_39_absl_py": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", - "extra_pip_args": [ - "--require-hashes" - ], - "python_interpreter_target": "@@+python+python_3_9_host//:python", - "repo": "rules_fuzzing_py_deps_39", - "requirement": "absl-py==2.0.0 --hash=sha256:9a28abb62774ae4e8edbe2dd4c49ffcd45a6a848952a5eccc6a49f3f0fc1e2f3" - } - }, - "rules_fuzzing_py_deps_39_six": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_fuzzing_py_deps//{name}:{target}", - "extra_pip_args": [ - "--require-hashes" - ], - "python_interpreter_target": "@@+python+python_3_9_host//:python", - "repo": "rules_fuzzing_py_deps_39", - "requirement": "six==1.16.0 --hash=sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254" - } - }, - "rules_python_publish_deps_311_backports_tarfile_py3_none_any_77e284d7": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "backports.tarfile-1.2.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "backports-tarfile==1.2.0", - "sha256": "77e284d754527b01fb1e6fa8a1afe577858ebe4e9dad8919e34c862cb399bc34", - "urls": [ - "https://files.pythonhosted.org/packages/b9/fa/123043af240e49752f1c4bd24da5053b6bd00cad78c2be53c0d1e8b975bc/backports.tarfile-1.2.0-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_backports_tarfile_sdist_d75e02c2": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "backports_tarfile-1.2.0.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "backports-tarfile==1.2.0", - "sha256": "d75e02c268746e1b8144c278978b6e98e85de6ad16f8e4b0844a154557eca991", - "urls": [ - "https://files.pythonhosted.org/packages/86/72/cd9b395f25e290e633655a100af28cb253e4393396264a98bd5f5951d50f/backports_tarfile-1.2.0.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_certifi_py3_none_any_922820b5": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "certifi-2024.8.30-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "certifi==2024.8.30", - "sha256": "922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8", - "urls": [ - "https://files.pythonhosted.org/packages/12/90/3c9ff0512038035f59d279fddeb79f5f1eccd8859f06d6163c58798b9487/certifi-2024.8.30-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_certifi_sdist_bec941d2": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "certifi-2024.8.30.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "certifi==2024.8.30", - "sha256": "bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9", - "urls": [ - "https://files.pythonhosted.org/packages/b0/ee/9b19140fe824b367c04c5e1b369942dd754c4c5462d5674002f75c4dedc1/certifi-2024.8.30.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_cffi_cp311_cp311_manylinux_2_17_aarch64_a1ed2dd2": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "filename": "cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "cffi==1.17.1", - "sha256": "a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41", - "urls": [ - "https://files.pythonhosted.org/packages/2e/ea/70ce63780f096e16ce8588efe039d3c4f91deb1dc01e9c73a287939c79a6/cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" - ] - } - }, - "rules_python_publish_deps_311_cffi_cp311_cp311_manylinux_2_17_ppc64le_46bf4316": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "filename": "cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "cffi==1.17.1", - "sha256": "46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1", - "urls": [ - "https://files.pythonhosted.org/packages/1c/a0/a4fa9f4f781bda074c3ddd57a572b060fa0df7655d2a4247bbe277200146/cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl" - ] - } - }, - "rules_python_publish_deps_311_cffi_cp311_cp311_manylinux_2_17_s390x_a24ed04c": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "filename": "cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "cffi==1.17.1", - "sha256": "a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6", - "urls": [ - "https://files.pythonhosted.org/packages/62/12/ce8710b5b8affbcdd5c6e367217c242524ad17a02fe5beec3ee339f69f85/cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl" - ] - } - }, - "rules_python_publish_deps_311_cffi_cp311_cp311_manylinux_2_17_x86_64_610faea7": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "filename": "cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "cffi==1.17.1", - "sha256": "610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d", - "urls": [ - "https://files.pythonhosted.org/packages/ff/6b/d45873c5e0242196f042d555526f92aa9e0c32355a1be1ff8c27f077fd37/cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" - ] - } - }, - "rules_python_publish_deps_311_cffi_cp311_cp311_musllinux_1_1_aarch64_a9b15d49": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "filename": "cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "cffi==1.17.1", - "sha256": "a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6", - "urls": [ - "https://files.pythonhosted.org/packages/1a/52/d9a0e523a572fbccf2955f5abe883cfa8bcc570d7faeee06336fbd50c9fc/cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl" - ] - } - }, - "rules_python_publish_deps_311_cffi_cp311_cp311_musllinux_1_1_x86_64_fc48c783": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "filename": "cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "cffi==1.17.1", - "sha256": "fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b", - "urls": [ - "https://files.pythonhosted.org/packages/f8/4a/34599cac7dfcd888ff54e801afe06a19c17787dfd94495ab0c8d35fe99fb/cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl" - ] - } - }, - "rules_python_publish_deps_311_cffi_sdist_1c39c601": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "cffi-1.17.1.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "cffi==1.17.1", - "sha256": "1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", - "urls": [ - "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_macosx_10_9_universal2_0d99dd8f": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "0d99dd8ff461990f12d6e42c7347fd9ab2532fb70e9621ba520f9e8637161d7c", - "urls": [ - "https://files.pythonhosted.org/packages/9c/61/73589dcc7a719582bf56aae309b6103d2762b526bffe189d635a7fcfd998/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl" - ] - } - }, - "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_macosx_10_9_x86_64_c57516e5": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "c57516e58fd17d03ebe67e181a4e4e2ccab1168f8c2976c6a334d4f819fe5944", - "urls": [ - "https://files.pythonhosted.org/packages/77/d5/8c982d58144de49f59571f940e329ad6e8615e1e82ef84584c5eeb5e1d72/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl" - ] - } - }, - "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_macosx_11_0_arm64_6dba5d19": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "6dba5d19c4dfab08e58d5b36304b3f92f3bd5d42c1a3fa37b5ba5cdf6dfcbcee", - "urls": [ - "https://files.pythonhosted.org/packages/bf/19/411a64f01ee971bed3231111b69eb56f9331a769072de479eae7de52296d/charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl" - ] - } - }, - "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_manylinux_2_17_aarch64_bf4475b8": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "bf4475b82be41b07cc5e5ff94810e6a01f276e37c2d55571e3fe175e467a1a1c", - "urls": [ - "https://files.pythonhosted.org/packages/4c/92/97509850f0d00e9f14a46bc751daabd0ad7765cff29cdfb66c68b6dad57f/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" - ] - } - }, - "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_manylinux_2_17_ppc64le_ce031db0": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "ce031db0408e487fd2775d745ce30a7cd2923667cf3b69d48d219f1d8f5ddeb6", - "urls": [ - "https://files.pythonhosted.org/packages/e2/29/d227805bff72ed6d6cb1ce08eec707f7cfbd9868044893617eb331f16295/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl" - ] - } - }, - "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_manylinux_2_17_s390x_8ff4e7cd": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "8ff4e7cdfdb1ab5698e675ca622e72d58a6fa2a8aa58195de0c0061288e6e3ea", - "urls": [ - "https://files.pythonhosted.org/packages/13/bc/87c2c9f2c144bedfa62f894c3007cd4530ba4b5351acb10dc786428a50f0/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl" - ] - } - }, - "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_manylinux_2_17_x86_64_3710a975": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "3710a9751938947e6327ea9f3ea6332a09bf0ba0c09cae9cb1f250bd1f1549bc", - "urls": [ - "https://files.pythonhosted.org/packages/eb/5b/6f10bad0f6461fa272bfbbdf5d0023b5fb9bc6217c92bf068fa5a99820f5/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" - ] - } - }, - "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_musllinux_1_2_aarch64_47334db7": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "47334db71978b23ebcf3c0f9f5ee98b8d65992b65c9c4f2d34c2eaf5bcaf0594", - "urls": [ - "https://files.pythonhosted.org/packages/d7/a1/493919799446464ed0299c8eef3c3fad0daf1c3cd48bff9263c731b0d9e2/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl" - ] - } - }, - "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_musllinux_1_2_ppc64le_f1a2f519": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "f1a2f519ae173b5b6a2c9d5fa3116ce16e48b3462c8b96dfdded11055e3d6365", - "urls": [ - "https://files.pythonhosted.org/packages/75/d2/0ab54463d3410709c09266dfb416d032a08f97fd7d60e94b8c6ef54ae14b/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl" - ] - } - }, - "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_musllinux_1_2_s390x_63bc5c4a": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "63bc5c4ae26e4bc6be6469943b8253c0fd4e4186c43ad46e713ea61a0ba49129", - "urls": [ - "https://files.pythonhosted.org/packages/8d/c9/27e41d481557be53d51e60750b85aa40eaf52b841946b3cdeff363105737/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl" - ] - } - }, - "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_musllinux_1_2_x86_64_bcb4f8ea": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "bcb4f8ea87d03bc51ad04add8ceaf9b0f085ac045ab4d74e73bbc2dc033f0236", - "urls": [ - "https://files.pythonhosted.org/packages/ee/44/4f62042ca8cdc0cabf87c0fc00ae27cd8b53ab68be3605ba6d071f742ad3/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl" - ] - } - }, - "rules_python_publish_deps_311_charset_normalizer_cp311_cp311_win_amd64_cee4373f": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "cee4373f4d3ad28f1ab6290684d8e2ebdb9e7a1b74fdc39e4c211995f77bec27", - "urls": [ - "https://files.pythonhosted.org/packages/0b/6e/b13bd47fa9023b3699e94abf565b5a2f0b0be6e9ddac9812182596ee62e4/charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl" - ] - } - }, - "rules_python_publish_deps_311_charset_normalizer_py3_none_any_fe9f97fe": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "charset_normalizer-3.4.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "fe9f97feb71aa9896b81973a7bbada8c49501dc73e58a10fcef6663af95e5079", - "urls": [ - "https://files.pythonhosted.org/packages/bf/9b/08c0432272d77b04803958a4598a51e2a4b51c06640af8b8f0f908c18bf2/charset_normalizer-3.4.0-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_charset_normalizer_sdist_223217c3": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "charset_normalizer-3.4.0.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "charset-normalizer==3.4.0", - "sha256": "223217c3d4f82c3ac5e29032b3f1c2eb0fb591b72161f86d93f5719079dae93e", - "urls": [ - "https://files.pythonhosted.org/packages/f2/4f/e1808dc01273379acc506d18f1504eb2d299bd4131743b9fc54d7be4df1e/charset_normalizer-3.4.0.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_cryptography_cp39_abi3_manylinux_2_17_aarch64_846da004": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "filename": "cryptography-43.0.3-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "cryptography==43.0.3", - "sha256": "846da004a5804145a5f441b8530b4bf35afbf7da70f82409f151695b127213d5", - "urls": [ - "https://files.pythonhosted.org/packages/2f/78/55356eb9075d0be6e81b59f45c7b48df87f76a20e73893872170471f3ee8/cryptography-43.0.3-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" - ] - } - }, - "rules_python_publish_deps_311_cryptography_cp39_abi3_manylinux_2_17_x86_64_0f996e72": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "filename": "cryptography-43.0.3-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "cryptography==43.0.3", - "sha256": "0f996e7268af62598f2fc1204afa98a3b5712313a55c4c9d434aef49cadc91d4", - "urls": [ - "https://files.pythonhosted.org/packages/2a/2c/488776a3dc843f95f86d2f957ca0fc3407d0242b50bede7fad1e339be03f/cryptography-43.0.3-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" - ] - } - }, - "rules_python_publish_deps_311_cryptography_cp39_abi3_manylinux_2_28_aarch64_f7b178f1": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "filename": "cryptography-43.0.3-cp39-abi3-manylinux_2_28_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "cryptography==43.0.3", - "sha256": "f7b178f11ed3664fd0e995a47ed2b5ff0a12d893e41dd0494f406d1cf555cab7", - "urls": [ - "https://files.pythonhosted.org/packages/7c/04/2345ca92f7a22f601a9c62961741ef7dd0127c39f7310dffa0041c80f16f/cryptography-43.0.3-cp39-abi3-manylinux_2_28_aarch64.whl" - ] - } - }, - "rules_python_publish_deps_311_cryptography_cp39_abi3_manylinux_2_28_x86_64_c2e6fc39": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "filename": "cryptography-43.0.3-cp39-abi3-manylinux_2_28_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "cryptography==43.0.3", - "sha256": "c2e6fc39c4ab499049df3bdf567f768a723a5e8464816e8f009f121a5a9f4405", - "urls": [ - "https://files.pythonhosted.org/packages/ac/25/e715fa0bc24ac2114ed69da33adf451a38abb6f3f24ec207908112e9ba53/cryptography-43.0.3-cp39-abi3-manylinux_2_28_x86_64.whl" - ] - } - }, - "rules_python_publish_deps_311_cryptography_cp39_abi3_musllinux_1_2_aarch64_e1be4655": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "filename": "cryptography-43.0.3-cp39-abi3-musllinux_1_2_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "cryptography==43.0.3", - "sha256": "e1be4655c7ef6e1bbe6b5d0403526601323420bcf414598955968c9ef3eb7d16", - "urls": [ - "https://files.pythonhosted.org/packages/21/ce/b9c9ff56c7164d8e2edfb6c9305045fbc0df4508ccfdb13ee66eb8c95b0e/cryptography-43.0.3-cp39-abi3-musllinux_1_2_aarch64.whl" - ] - } - }, - "rules_python_publish_deps_311_cryptography_cp39_abi3_musllinux_1_2_x86_64_df6b6c6d": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "filename": "cryptography-43.0.3-cp39-abi3-musllinux_1_2_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "cryptography==43.0.3", - "sha256": "df6b6c6d742395dd77a23ea3728ab62f98379eff8fb61be2744d4679ab678f73", - "urls": [ - "https://files.pythonhosted.org/packages/2a/33/b3682992ab2e9476b9c81fff22f02c8b0a1e6e1d49ee1750a67d85fd7ed2/cryptography-43.0.3-cp39-abi3-musllinux_1_2_x86_64.whl" - ] - } - }, - "rules_python_publish_deps_311_cryptography_sdist_315b9001": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "cryptography-43.0.3.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "cryptography==43.0.3", - "sha256": "315b9001266a492a6ff443b61238f956b214dbec9910a081ba5b6646a055a805", - "urls": [ - "https://files.pythonhosted.org/packages/0d/05/07b55d1fa21ac18c3a8c79f764e2514e6f6a9698f1be44994f5adf0d29db/cryptography-43.0.3.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_docutils_py3_none_any_dafca5b9": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "docutils-0.21.2-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "docutils==0.21.2", - "sha256": "dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2", - "urls": [ - "https://files.pythonhosted.org/packages/8f/d7/9322c609343d929e75e7e5e6255e614fcc67572cfd083959cdef3b7aad79/docutils-0.21.2-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_docutils_sdist_3a6b1873": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "docutils-0.21.2.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "docutils==0.21.2", - "sha256": "3a6b18732edf182daa3cd12775bbb338cf5691468f91eeeb109deff6ebfa986f", - "urls": [ - "https://files.pythonhosted.org/packages/ae/ed/aefcc8cd0ba62a0560c3c18c33925362d46c6075480bfa4df87b28e169a9/docutils-0.21.2.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_idna_py3_none_any_946d195a": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "idna-3.10-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "idna==3.10", - "sha256": "946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", - "urls": [ - "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_idna_sdist_12f65c9b": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "idna-3.10.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "idna==3.10", - "sha256": "12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", - "urls": [ - "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_importlib_metadata_py3_none_any_45e54197": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "importlib_metadata-8.5.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "importlib-metadata==8.5.0", - "sha256": "45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b", - "urls": [ - "https://files.pythonhosted.org/packages/a0/d9/a1e041c5e7caa9a05c925f4bdbdfb7f006d1f74996af53467bc394c97be7/importlib_metadata-8.5.0-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_importlib_metadata_sdist_71522656": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "importlib_metadata-8.5.0.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "importlib-metadata==8.5.0", - "sha256": "71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7", - "urls": [ - "https://files.pythonhosted.org/packages/cd/12/33e59336dca5be0c398a7482335911a33aa0e20776128f038019f1a95f1b/importlib_metadata-8.5.0.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_jaraco_classes_py3_none_any_f662826b": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "jaraco.classes-3.4.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "jaraco-classes==3.4.0", - "sha256": "f662826b6bed8cace05e7ff873ce0f9283b5c924470fe664fff1c2f00f581790", - "urls": [ - "https://files.pythonhosted.org/packages/7f/66/b15ce62552d84bbfcec9a4873ab79d993a1dd4edb922cbfccae192bd5b5f/jaraco.classes-3.4.0-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_jaraco_classes_sdist_47a024b5": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "jaraco.classes-3.4.0.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "jaraco-classes==3.4.0", - "sha256": "47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd", - "urls": [ - "https://files.pythonhosted.org/packages/06/c0/ed4a27bc5571b99e3cff68f8a9fa5b56ff7df1c2251cc715a652ddd26402/jaraco.classes-3.4.0.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_jaraco_context_py3_none_any_f797fc48": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "jaraco.context-6.0.1-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "jaraco-context==6.0.1", - "sha256": "f797fc481b490edb305122c9181830a3a5b76d84ef6d1aef2fb9b47ab956f9e4", - "urls": [ - "https://files.pythonhosted.org/packages/ff/db/0c52c4cf5e4bd9f5d7135ec7669a3a767af21b3a308e1ed3674881e52b62/jaraco.context-6.0.1-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_jaraco_context_sdist_9bae4ea5": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "jaraco_context-6.0.1.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "jaraco-context==6.0.1", - "sha256": "9bae4ea555cf0b14938dc0aee7c9f32ed303aa20a3b73e7dc80111628792d1b3", - "urls": [ - "https://files.pythonhosted.org/packages/df/ad/f3777b81bf0b6e7bc7514a1656d3e637b2e8e15fab2ce3235730b3e7a4e6/jaraco_context-6.0.1.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_jaraco_functools_py3_none_any_ad159f13": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "jaraco.functools-4.1.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "jaraco-functools==4.1.0", - "sha256": "ad159f13428bc4acbf5541ad6dec511f91573b90fba04df61dafa2a1231cf649", - "urls": [ - "https://files.pythonhosted.org/packages/9f/4f/24b319316142c44283d7540e76c7b5a6dbd5db623abd86bb7b3491c21018/jaraco.functools-4.1.0-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_jaraco_functools_sdist_70f7e0e2": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "jaraco_functools-4.1.0.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "jaraco-functools==4.1.0", - "sha256": "70f7e0e2ae076498e212562325e805204fc092d7b4c17e0e86c959e249701a9d", - "urls": [ - "https://files.pythonhosted.org/packages/ab/23/9894b3df5d0a6eb44611c36aec777823fc2e07740dabbd0b810e19594013/jaraco_functools-4.1.0.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_jeepney_py3_none_any_c0a454ad": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "filename": "jeepney-0.8.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "jeepney==0.8.0", - "sha256": "c0a454ad016ca575060802ee4d590dd912e35c122fa04e70306de3d076cce755", - "urls": [ - "https://files.pythonhosted.org/packages/ae/72/2a1e2290f1ab1e06f71f3d0f1646c9e4634e70e1d37491535e19266e8dc9/jeepney-0.8.0-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_jeepney_sdist_5efe48d2": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "jeepney-0.8.0.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "jeepney==0.8.0", - "sha256": "5efe48d255973902f6badc3ce55e2aa6c5c3b3bc642059ef3a91247bcfcc5806", - "urls": [ - "https://files.pythonhosted.org/packages/d6/f4/154cf374c2daf2020e05c3c6a03c91348d59b23c5366e968feb198306fdf/jeepney-0.8.0.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_keyring_py3_none_any_5426f817": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "keyring-25.4.1-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "keyring==25.4.1", - "sha256": "5426f817cf7f6f007ba5ec722b1bcad95a75b27d780343772ad76b17cb47b0bf", - "urls": [ - "https://files.pythonhosted.org/packages/83/25/e6d59e5f0a0508d0dca8bb98c7f7fd3772fc943ac3f53d5ab18a218d32c0/keyring-25.4.1-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_keyring_sdist_b07ebc55": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "keyring-25.4.1.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "keyring==25.4.1", - "sha256": "b07ebc55f3e8ed86ac81dd31ef14e81ace9dd9c3d4b5d77a6e9a2016d0d71a1b", - "urls": [ - "https://files.pythonhosted.org/packages/a5/1c/2bdbcfd5d59dc6274ffb175bc29aa07ecbfab196830e0cfbde7bd861a2ea/keyring-25.4.1.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_markdown_it_py_py3_none_any_35521684": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "markdown_it_py-3.0.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "markdown-it-py==3.0.0", - "sha256": "355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", - "urls": [ - "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_markdown_it_py_sdist_e3f60a94": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "markdown-it-py-3.0.0.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "markdown-it-py==3.0.0", - "sha256": "e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", - "urls": [ - "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_mdurl_py3_none_any_84008a41": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "mdurl-0.1.2-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "mdurl==0.1.2", - "sha256": "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", - "urls": [ - "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_mdurl_sdist_bb413d29": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "mdurl-0.1.2.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "mdurl==0.1.2", - "sha256": "bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", - "urls": [ - "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_more_itertools_py3_none_any_037b0d32": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "more_itertools-10.5.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "more-itertools==10.5.0", - "sha256": "037b0d3203ce90cca8ab1defbbdac29d5f993fc20131f3664dc8d6acfa872aef", - "urls": [ - "https://files.pythonhosted.org/packages/48/7e/3a64597054a70f7c86eb0a7d4fc315b8c1ab932f64883a297bdffeb5f967/more_itertools-10.5.0-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_more_itertools_sdist_5482bfef": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "more-itertools-10.5.0.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "more-itertools==10.5.0", - "sha256": "5482bfef7849c25dc3c6dd53a6173ae4795da2a41a80faea6700d9f5846c5da6", - "urls": [ - "https://files.pythonhosted.org/packages/51/78/65922308c4248e0eb08ebcbe67c95d48615cc6f27854b6f2e57143e9178f/more-itertools-10.5.0.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_nh3_cp37_abi3_macosx_10_12_x86_64_14c5a72e": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "nh3-0.2.18-cp37-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "nh3==0.2.18", - "sha256": "14c5a72e9fe82aea5fe3072116ad4661af5cf8e8ff8fc5ad3450f123e4925e86", - "urls": [ - "https://files.pythonhosted.org/packages/b3/89/1daff5d9ba5a95a157c092c7c5f39b8dd2b1ddb4559966f808d31cfb67e0/nh3-0.2.18-cp37-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl" - ] - } - }, - "rules_python_publish_deps_311_nh3_cp37_abi3_macosx_10_12_x86_64_7b7c2a3c": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "nh3-0.2.18-cp37-abi3-macosx_10_12_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "nh3==0.2.18", - "sha256": "7b7c2a3c9eb1a827d42539aa64091640bd275b81e097cd1d8d82ef91ffa2e811", - "urls": [ - "https://files.pythonhosted.org/packages/2c/b6/42fc3c69cabf86b6b81e4c051a9b6e249c5ba9f8155590222c2622961f58/nh3-0.2.18-cp37-abi3-macosx_10_12_x86_64.whl" - ] - } - }, - "rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_aarch64_42c64511": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "nh3-0.2.18-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "nh3==0.2.18", - "sha256": "42c64511469005058cd17cc1537578eac40ae9f7200bedcfd1fc1a05f4f8c200", - "urls": [ - "https://files.pythonhosted.org/packages/45/b9/833f385403abaf0023c6547389ec7a7acf141ddd9d1f21573723a6eab39a/nh3-0.2.18-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl" - ] - } - }, - "rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_armv7l_0411beb0": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "nh3-0.2.18-cp37-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "nh3==0.2.18", - "sha256": "0411beb0589eacb6734f28d5497ca2ed379eafab8ad8c84b31bb5c34072b7164", - "urls": [ - "https://files.pythonhosted.org/packages/05/2b/85977d9e11713b5747595ee61f381bc820749daf83f07b90b6c9964cf932/nh3-0.2.18-cp37-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl" - ] - } - }, - "rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_ppc64_5f36b271": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "nh3-0.2.18-cp37-abi3-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "nh3==0.2.18", - "sha256": "5f36b271dae35c465ef5e9090e1fdaba4a60a56f0bb0ba03e0932a66f28b9189", - "urls": [ - "https://files.pythonhosted.org/packages/72/f2/5c894d5265ab80a97c68ca36f25c8f6f0308abac649aaf152b74e7e854a8/nh3-0.2.18-cp37-abi3-manylinux_2_17_ppc64.manylinux2014_ppc64.whl" - ] - } - }, - "rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_ppc64le_34c03fa7": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "nh3-0.2.18-cp37-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "nh3==0.2.18", - "sha256": "34c03fa78e328c691f982b7c03d4423bdfd7da69cd707fe572f544cf74ac23ad", - "urls": [ - "https://files.pythonhosted.org/packages/ab/a7/375afcc710dbe2d64cfbd69e31f82f3e423d43737258af01f6a56d844085/nh3-0.2.18-cp37-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl" - ] - } - }, - "rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_s390x_19aaba96": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "nh3-0.2.18-cp37-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "nh3==0.2.18", - "sha256": "19aaba96e0f795bd0a6c56291495ff59364f4300d4a39b29a0abc9cb3774a84b", - "urls": [ - "https://files.pythonhosted.org/packages/c2/a8/3bb02d0c60a03ad3a112b76c46971e9480efa98a8946677b5a59f60130ca/nh3-0.2.18-cp37-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl" - ] - } - }, - "rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_x86_64_de3ceed6": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "nh3-0.2.18-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "nh3==0.2.18", - "sha256": "de3ceed6e661954871d6cd78b410213bdcb136f79aafe22aa7182e028b8c7307", - "urls": [ - "https://files.pythonhosted.org/packages/1b/63/6ab90d0e5225ab9780f6c9fb52254fa36b52bb7c188df9201d05b647e5e1/nh3-0.2.18-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl" - ] - } - }, - "rules_python_publish_deps_311_nh3_cp37_abi3_musllinux_1_2_aarch64_f0eca9ca": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "nh3-0.2.18-cp37-abi3-musllinux_1_2_aarch64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "nh3==0.2.18", - "sha256": "f0eca9ca8628dbb4e916ae2491d72957fdd35f7a5d326b7032a345f111ac07fe", - "urls": [ - "https://files.pythonhosted.org/packages/a3/da/0c4e282bc3cff4a0adf37005fa1fb42257673fbc1bbf7d1ff639ec3d255a/nh3-0.2.18-cp37-abi3-musllinux_1_2_aarch64.whl" - ] - } - }, - "rules_python_publish_deps_311_nh3_cp37_abi3_musllinux_1_2_armv7l_3a157ab1": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "nh3-0.2.18-cp37-abi3-musllinux_1_2_armv7l.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "nh3==0.2.18", - "sha256": "3a157ab149e591bb638a55c8c6bcb8cdb559c8b12c13a8affaba6cedfe51713a", - "urls": [ - "https://files.pythonhosted.org/packages/de/81/c291231463d21da5f8bba82c8167a6d6893cc5419b0639801ee5d3aeb8a9/nh3-0.2.18-cp37-abi3-musllinux_1_2_armv7l.whl" - ] - } - }, - "rules_python_publish_deps_311_nh3_cp37_abi3_musllinux_1_2_x86_64_36c95d4b": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "nh3-0.2.18-cp37-abi3-musllinux_1_2_x86_64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "nh3==0.2.18", - "sha256": "36c95d4b70530b320b365659bb5034341316e6a9b30f0b25fa9c9eff4c27a204", - "urls": [ - "https://files.pythonhosted.org/packages/eb/61/73a007c74c37895fdf66e0edcd881f5eaa17a348ff02f4bb4bc906d61085/nh3-0.2.18-cp37-abi3-musllinux_1_2_x86_64.whl" - ] - } - }, - "rules_python_publish_deps_311_nh3_cp37_abi3_win_amd64_8ce0f819": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "nh3-0.2.18-cp37-abi3-win_amd64.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "nh3==0.2.18", - "sha256": "8ce0f819d2f1933953fca255db2471ad58184a60508f03e6285e5114b6254844", - "urls": [ - "https://files.pythonhosted.org/packages/26/8d/53c5b19c4999bdc6ba95f246f4ef35ca83d7d7423e5e38be43ad66544e5d/nh3-0.2.18-cp37-abi3-win_amd64.whl" - ] - } - }, - "rules_python_publish_deps_311_nh3_sdist_94a16692": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "nh3-0.2.18.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "nh3==0.2.18", - "sha256": "94a166927e53972a9698af9542ace4e38b9de50c34352b962f4d9a7d4c927af4", - "urls": [ - "https://files.pythonhosted.org/packages/62/73/10df50b42ddb547a907deeb2f3c9823022580a7a47281e8eae8e003a9639/nh3-0.2.18.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_pkginfo_py3_none_any_889a6da2": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "pkginfo-1.10.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "pkginfo==1.10.0", - "sha256": "889a6da2ed7ffc58ab5b900d888ddce90bce912f2d2de1dc1c26f4cb9fe65097", - "urls": [ - "https://files.pythonhosted.org/packages/56/09/054aea9b7534a15ad38a363a2bd974c20646ab1582a387a95b8df1bfea1c/pkginfo-1.10.0-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_pkginfo_sdist_5df73835": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "pkginfo-1.10.0.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "pkginfo==1.10.0", - "sha256": "5df73835398d10db79f8eecd5cd86b1f6d29317589ea70796994d49399af6297", - "urls": [ - "https://files.pythonhosted.org/packages/2f/72/347ec5be4adc85c182ed2823d8d1c7b51e13b9a6b0c1aae59582eca652df/pkginfo-1.10.0.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_pycparser_py3_none_any_c3702b6d": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "filename": "pycparser-2.22-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "pycparser==2.22", - "sha256": "c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", - "urls": [ - "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_pycparser_sdist_491c8be9": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "pycparser-2.22.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "pycparser==2.22", - "sha256": "491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", - "urls": [ - "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_pygments_py3_none_any_b8e6aca0": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "pygments-2.18.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "pygments==2.18.0", - "sha256": "b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a", - "urls": [ - "https://files.pythonhosted.org/packages/f7/3f/01c8b82017c199075f8f788d0d906b9ffbbc5a47dc9918a945e13d5a2bda/pygments-2.18.0-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_pygments_sdist_786ff802": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "pygments-2.18.0.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "pygments==2.18.0", - "sha256": "786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199", - "urls": [ - "https://files.pythonhosted.org/packages/8e/62/8336eff65bcbc8e4cb5d05b55faf041285951b6e80f33e2bff2024788f31/pygments-2.18.0.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_pywin32_ctypes_py3_none_any_8a151337": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_windows_x86_64" - ], - "filename": "pywin32_ctypes-0.2.3-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "pywin32-ctypes==0.2.3", - "sha256": "8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", - "urls": [ - "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_pywin32_ctypes_sdist_d162dc04": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "pywin32-ctypes-0.2.3.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "pywin32-ctypes==0.2.3", - "sha256": "d162dc04946d704503b2edc4d55f3dba5c1d539ead017afa00142c38b9885755", - "urls": [ - "https://files.pythonhosted.org/packages/85/9f/01a1a99704853cb63f253eea009390c88e7131c67e66a0a02099a8c917cb/pywin32-ctypes-0.2.3.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_readme_renderer_py3_none_any_2fbca89b": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "readme_renderer-44.0-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "readme-renderer==44.0", - "sha256": "2fbca89b81a08526aadf1357a8c2ae889ec05fb03f5da67f9769c9a592166151", - "urls": [ - "https://files.pythonhosted.org/packages/e1/67/921ec3024056483db83953ae8e48079ad62b92db7880013ca77632921dd0/readme_renderer-44.0-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_readme_renderer_sdist_8712034e": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "readme_renderer-44.0.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "readme-renderer==44.0", - "sha256": "8712034eabbfa6805cacf1402b4eeb2a73028f72d1166d6f5cb7f9c047c5d1e1", - "urls": [ - "https://files.pythonhosted.org/packages/5a/a9/104ec9234c8448c4379768221ea6df01260cd6c2ce13182d4eac531c8342/readme_renderer-44.0.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_requests_py3_none_any_70761cfe": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "requests-2.32.3-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "requests==2.32.3", - "sha256": "70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", - "urls": [ - "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_requests_sdist_55365417": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "requests-2.32.3.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "requests==2.32.3", - "sha256": "55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", - "urls": [ - "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_requests_toolbelt_py2_none_any_cccfdd66": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "requests_toolbelt-1.0.0-py2.py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "requests-toolbelt==1.0.0", - "sha256": "cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", - "urls": [ - "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_requests_toolbelt_sdist_7681a0a3": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "requests-toolbelt-1.0.0.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "requests-toolbelt==1.0.0", - "sha256": "7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6", - "urls": [ - "https://files.pythonhosted.org/packages/f3/61/d7545dafb7ac2230c70d38d31cbfe4cc64f7144dc41f6e4e4b78ecd9f5bb/requests-toolbelt-1.0.0.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_rfc3986_py2_none_any_50b1502b": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "rfc3986-2.0.0-py2.py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "rfc3986==2.0.0", - "sha256": "50b1502b60e289cb37883f3dfd34532b8873c7de9f49bb546641ce9cbd256ebd", - "urls": [ - "https://files.pythonhosted.org/packages/ff/9a/9afaade874b2fa6c752c36f1548f718b5b83af81ed9b76628329dab81c1b/rfc3986-2.0.0-py2.py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_rfc3986_sdist_97aacf9d": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "rfc3986-2.0.0.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "rfc3986==2.0.0", - "sha256": "97aacf9dbd4bfd829baad6e6309fa6573aaf1be3f6fa735c8ab05e46cecb261c", - "urls": [ - "https://files.pythonhosted.org/packages/85/40/1520d68bfa07ab5a6f065a186815fb6610c86fe957bc065754e47f7b0840/rfc3986-2.0.0.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_rich_py3_none_any_6049d5e6": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "rich-13.9.4-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "rich==13.9.4", - "sha256": "6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90", - "urls": [ - "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_rich_sdist_43959497": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "rich-13.9.4.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "rich==13.9.4", - "sha256": "439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098", - "urls": [ - "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_secretstorage_py3_none_any_f356e662": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "filename": "SecretStorage-3.3.3-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "secretstorage==3.3.3", - "sha256": "f356e6628222568e3af06f2eba8df495efa13b3b63081dafd4f7d9a7b7bc9f99", - "urls": [ - "https://files.pythonhosted.org/packages/54/24/b4293291fa1dd830f353d2cb163295742fa87f179fcc8a20a306a81978b7/SecretStorage-3.3.3-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_secretstorage_sdist_2403533e": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "SecretStorage-3.3.3.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "secretstorage==3.3.3", - "sha256": "2403533ef369eca6d2ba81718576c5e0f564d5cca1b58f73a8b23e7d4eeebd77", - "urls": [ - "https://files.pythonhosted.org/packages/53/a4/f48c9d79cb507ed1373477dbceaba7401fd8a23af63b837fa61f1dcd3691/SecretStorage-3.3.3.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_twine_py3_none_any_215dbe7b": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "twine-5.1.1-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "twine==5.1.1", - "sha256": "215dbe7b4b94c2c50a7315c0275d2258399280fbb7d04182c7e55e24b5f93997", - "urls": [ - "https://files.pythonhosted.org/packages/5d/ec/00f9d5fd040ae29867355e559a94e9a8429225a0284a3f5f091a3878bfc0/twine-5.1.1-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_twine_sdist_9aa08251": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "twine-5.1.1.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "twine==5.1.1", - "sha256": "9aa0825139c02b3434d913545c7b847a21c835e11597f5255842d457da2322db", - "urls": [ - "https://files.pythonhosted.org/packages/77/68/bd982e5e949ef8334e6f7dcf76ae40922a8750aa2e347291ae1477a4782b/twine-5.1.1.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_urllib3_py3_none_any_ca899ca0": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "urllib3-2.2.3-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "urllib3==2.2.3", - "sha256": "ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac", - "urls": [ - "https://files.pythonhosted.org/packages/ce/d9/5f4c13cecde62396b0d3fe530a50ccea91e7dfc1ccf0e09c228841bb5ba8/urllib3-2.2.3-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_urllib3_sdist_e7d814a8": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "urllib3-2.2.3.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "urllib3==2.2.3", - "sha256": "e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9", - "urls": [ - "https://files.pythonhosted.org/packages/ed/63/22ba4ebfe7430b76388e7cd448d5478814d3032121827c12a2cc287e2260/urllib3-2.2.3.tar.gz" - ] - } - }, - "rules_python_publish_deps_311_zipp_py3_none_any_a817ac80": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "filename": "zipp-3.20.2-py3-none-any.whl", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "zipp==3.20.2", - "sha256": "a817ac80d6cf4b23bf7f2828b7cabf326f15a001bea8b1f9b49631780ba28350", - "urls": [ - "https://files.pythonhosted.org/packages/62/8b/5ba542fa83c90e09eac972fc9baca7a88e7e7ca4b221a89251954019308b/zipp-3.20.2-py3-none-any.whl" - ] - } - }, - "rules_python_publish_deps_311_zipp_sdist_bc9eb26f": { - "repoRuleId": "@@//python/private/pypi:whl_library.bzl%whl_library", - "attributes": { - "dep_template": "@rules_python_publish_deps//{name}:{target}", - "experimental_target_platforms": [ - "cp311_linux_aarch64", - "cp311_linux_arm", - "cp311_linux_ppc", - "cp311_linux_s390x", - "cp311_linux_x86_64", - "cp311_osx_aarch64", - "cp311_osx_x86_64", - "cp311_windows_x86_64" - ], - "extra_pip_args": [ - "--index-url", - "https://pypi.org/simple" - ], - "filename": "zipp-3.20.2.tar.gz", - "python_interpreter_target": "@@+python+python_3_11_host//:python", - "repo": "rules_python_publish_deps_311", - "requirement": "zipp==3.20.2", - "sha256": "bc9eb26f4506fda01b81bcde0ca78103b6e62f991b381fec825435c836edbc29", - "urls": [ - "https://files.pythonhosted.org/packages/54/bf/5c0000c44ebc80123ecbdddba1f5dcd94a5ada602a9c225d84b5aaa55e86/zipp-3.20.2.tar.gz" - ] - } - }, - "dev_pip": { - "repoRuleId": "@@//python/private/pypi:hub_repository.bzl%hub_repository", - "attributes": { - "repo_name": "dev_pip", - "extra_hub_aliases": {}, - "whl_map": { - "absl_py": "{\"dev_pip_311_absl_py_py3_none_any_526a04ea\":[{\"filename\":\"absl_py-2.1.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_absl_py_py3_none_any_526a04ea\":[{\"filename\":\"absl_py-2.1.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "alabaster": "{\"dev_pip_311_alabaster_py3_none_any_fc678640\":[{\"filename\":\"alabaster-1.0.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_alabaster_py3_none_any_fc678640\":[{\"filename\":\"alabaster-1.0.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "astroid": "{\"dev_pip_311_astroid_py3_none_any_db676dc4\":[{\"filename\":\"astroid-3.3.6-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_astroid_py3_none_any_db676dc4\":[{\"filename\":\"astroid-3.3.6-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "babel": "{\"dev_pip_311_babel_py3_none_any_368b5b98\":[{\"filename\":\"babel-2.16.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_babel_py3_none_any_368b5b98\":[{\"filename\":\"babel-2.16.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "certifi": "{\"dev_pip_311_certifi_py3_none_any_922820b5\":[{\"filename\":\"certifi-2024.8.30-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_certifi_py3_none_any_922820b5\":[{\"filename\":\"certifi-2024.8.30-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "charset_normalizer": "{\"dev_pip_311_charset_normalizer_cp311_cp311_macosx_10_9_universal2_0d99dd8f\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_macosx_10_9_x86_64_c57516e5\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_macosx_11_0_arm64_6dba5d19\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_manylinux_2_17_aarch64_bf4475b8\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_manylinux_2_17_ppc64le_ce031db0\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_manylinux_2_17_s390x_8ff4e7cd\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_manylinux_2_17_x86_64_3710a975\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_musllinux_1_2_aarch64_47334db7\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_musllinux_1_2_ppc64le_f1a2f519\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_musllinux_1_2_s390x_63bc5c4a\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_musllinux_1_2_x86_64_bcb4f8ea\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_cp311_cp311_win_amd64_cee4373f\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_charset_normalizer_py3_none_any_fe9f97fe\":[{\"filename\":\"charset_normalizer-3.4.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_macosx_10_13_universal2_dd4eda17\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_universal2.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_macosx_10_13_x86_64_e9e3c4c9\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_macosx_11_0_arm64_92a7e36b\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-macosx_11_0_arm64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_manylinux_2_17_aarch64_54b6a92d\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_manylinux_2_17_ppc64le_1ffd9493\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_manylinux_2_17_s390x_35c404d7\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_manylinux_2_17_x86_64_4796efc4\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_musllinux_1_2_aarch64_92db3c28\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_aarch64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_musllinux_1_2_ppc64le_4b67fdab\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_musllinux_1_2_s390x_aa41e526\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_s390x.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_musllinux_1_2_x86_64_ffc51962\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_cp313_cp313_win_amd64_707b82d1\":[{\"filename\":\"charset_normalizer-3.4.0-cp313-cp313-win_amd64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_charset_normalizer_py3_none_any_fe9f97fe\":[{\"filename\":\"charset_normalizer-3.4.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "colorama": "{\"dev_pip_311_colorama_py2_none_any_4f1d9991\":[{\"filename\":\"colorama-0.4.6-py2.py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_colorama_py2_none_any_4f1d9991\":[{\"filename\":\"colorama-0.4.6-py2.py3-none-any.whl\",\"version\":\"3.13\"}]}", - "docutils": "{\"dev_pip_311_docutils_py3_none_any_dafca5b9\":[{\"filename\":\"docutils-0.21.2-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_docutils_py3_none_any_dafca5b9\":[{\"filename\":\"docutils-0.21.2-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "idna": "{\"dev_pip_311_idna_py3_none_any_946d195a\":[{\"filename\":\"idna-3.10-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_idna_py3_none_any_946d195a\":[{\"filename\":\"idna-3.10-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "imagesize": "{\"dev_pip_311_imagesize_py2_none_any_0d8d18d0\":[{\"filename\":\"imagesize-1.4.1-py2.py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_imagesize_py2_none_any_0d8d18d0\":[{\"filename\":\"imagesize-1.4.1-py2.py3-none-any.whl\",\"version\":\"3.13\"}]}", - "jinja2": "{\"dev_pip_311_jinja2_py3_none_any_bc5dd2ab\":[{\"filename\":\"jinja2-3.1.4-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_jinja2_py3_none_any_bc5dd2ab\":[{\"filename\":\"jinja2-3.1.4-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "markdown_it_py": "{\"dev_pip_311_markdown_it_py_py3_none_any_35521684\":[{\"filename\":\"markdown_it_py-3.0.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_markdown_it_py_py3_none_any_35521684\":[{\"filename\":\"markdown_it_py-3.0.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "markupsafe": "{\"dev_pip_311_markupsafe_cp311_cp311_macosx_10_9_universal2_9025b401\":[{\"filename\":\"MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl\",\"version\":\"3.11\"}],\"dev_pip_311_markupsafe_cp311_cp311_macosx_11_0_arm64_93335ca3\":[{\"filename\":\"MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_markupsafe_cp311_cp311_manylinux_2_17_aarch64_2cb8438c\":[{\"filename\":\"MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_markupsafe_cp311_cp311_manylinux_2_17_x86_64_a123e330\":[{\"filename\":\"MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_markupsafe_cp311_cp311_musllinux_1_2_aarch64_d8213e09\":[{\"filename\":\"MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_markupsafe_cp311_cp311_musllinux_1_2_x86_64_0bff5e0a\":[{\"filename\":\"MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_markupsafe_cp311_cp311_win_amd64_70a87b41\":[{\"filename\":\"MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl\",\"version\":\"3.11\"}],\"dev_pip_313_markupsafe_cp313_cp313_macosx_10_13_universal2_ba9527cd\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313_macosx_11_0_arm64_f8b3d067\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313_manylinux_2_17_aarch64_569511d3\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313_manylinux_2_17_x86_64_15ab75ef\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313_musllinux_1_2_aarch64_cdb82a87\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313_musllinux_1_2_x86_64_444dcda7\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313_win_amd64_e6a2a455\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313t_macosx_10_13_universal2_b5a6b3ad\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313t_macosx_11_0_arm64_a904af0a\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313t_manylinux_2_17_aarch64_4aa4e5fa\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313t_manylinux_2_17_x86_64_c0ef13ea\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313t_musllinux_1_2_aarch64_6381026f\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313t_musllinux_1_2_x86_64_131a3c76\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_markupsafe_cp313_cp313t_win_amd64_e444a31f\":[{\"filename\":\"MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl\",\"version\":\"3.13\"}]}", - "mdit_py_plugins": "{\"dev_pip_311_mdit_py_plugins_py3_none_any_0c673c3f\":[{\"filename\":\"mdit_py_plugins-0.4.2-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_mdit_py_plugins_py3_none_any_0c673c3f\":[{\"filename\":\"mdit_py_plugins-0.4.2-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "mdurl": "{\"dev_pip_311_mdurl_py3_none_any_84008a41\":[{\"filename\":\"mdurl-0.1.2-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_mdurl_py3_none_any_84008a41\":[{\"filename\":\"mdurl-0.1.2-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "myst_parser": "{\"dev_pip_311_myst_parser_py3_none_any_b9317997\":[{\"filename\":\"myst_parser-4.0.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_myst_parser_py3_none_any_b9317997\":[{\"filename\":\"myst_parser-4.0.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "packaging": "{\"dev_pip_311_packaging_py3_none_any_5b8f2217\":[{\"filename\":\"packaging-24.1-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_packaging_py3_none_any_5b8f2217\":[{\"filename\":\"packaging-24.1-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "pygments": "{\"dev_pip_311_pygments_py3_none_any_b8e6aca0\":[{\"filename\":\"pygments-2.18.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_pygments_py3_none_any_b8e6aca0\":[{\"filename\":\"pygments-2.18.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "pyyaml": "{\"dev_pip_311_pyyaml_cp311_cp311_macosx_10_9_x86_64_cc1c1159\":[{\"filename\":\"PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_pyyaml_cp311_cp311_macosx_11_0_arm64_1e2120ef\":[{\"filename\":\"PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_pyyaml_cp311_cp311_manylinux_2_17_aarch64_5d225db5\":[{\"filename\":\"PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_pyyaml_cp311_cp311_manylinux_2_17_s390x_5ac9328e\":[{\"filename\":\"PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl\",\"version\":\"3.11\"}],\"dev_pip_311_pyyaml_cp311_cp311_manylinux_2_17_x86_64_3ad2a3de\":[{\"filename\":\"PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_pyyaml_cp311_cp311_musllinux_1_1_aarch64_ff3824dc\":[{\"filename\":\"PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_pyyaml_cp311_cp311_musllinux_1_1_x86_64_797b4f72\":[{\"filename\":\"PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl\",\"version\":\"3.11\"}],\"dev_pip_311_pyyaml_cp311_cp311_win_amd64_e10ce637\":[{\"filename\":\"PyYAML-6.0.2-cp311-cp311-win_amd64.whl\",\"version\":\"3.11\"}],\"dev_pip_313_pyyaml_cp313_cp313_macosx_10_13_x86_64_efdca563\":[{\"filename\":\"PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_pyyaml_cp313_cp313_macosx_11_0_arm64_50187695\":[{\"filename\":\"PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_pyyaml_cp313_cp313_manylinux_2_17_aarch64_0ffe8360\":[{\"filename\":\"PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_pyyaml_cp313_cp313_manylinux_2_17_s390x_17e311b6\":[{\"filename\":\"PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl\",\"version\":\"3.13\"}],\"dev_pip_313_pyyaml_cp313_cp313_manylinux_2_17_x86_64_70b18959\":[{\"filename\":\"PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_pyyaml_cp313_cp313_musllinux_1_1_aarch64_41e4e395\":[{\"filename\":\"PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_pyyaml_cp313_cp313_musllinux_1_1_x86_64_68ccc602\":[{\"filename\":\"PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl\",\"version\":\"3.13\"}],\"dev_pip_313_pyyaml_cp313_cp313_win_amd64_8388ee19\":[{\"filename\":\"PyYAML-6.0.2-cp313-cp313-win_amd64.whl\",\"version\":\"3.13\"}]}", - "readthedocs_sphinx_ext": "{\"dev_pip_311_readthedocs_sphinx_ext_py2_none_any_f8c56184\":[{\"filename\":\"readthedocs_sphinx_ext-2.2.5-py2.py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_readthedocs_sphinx_ext_py2_none_any_f8c56184\":[{\"filename\":\"readthedocs_sphinx_ext-2.2.5-py2.py3-none-any.whl\",\"version\":\"3.13\"}]}", - "requests": "{\"dev_pip_311_requests_py3_none_any_70761cfe\":[{\"filename\":\"requests-2.32.3-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_requests_py3_none_any_70761cfe\":[{\"filename\":\"requests-2.32.3-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "snowballstemmer": "{\"dev_pip_311_snowballstemmer_py2_none_any_c8e1716e\":[{\"filename\":\"snowballstemmer-2.2.0-py2.py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_snowballstemmer_py2_none_any_c8e1716e\":[{\"filename\":\"snowballstemmer-2.2.0-py2.py3-none-any.whl\",\"version\":\"3.13\"}]}", - "sphinx": "{\"dev_pip_311_sphinx_py3_none_any_09719015\":[{\"filename\":\"sphinx-8.1.3-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinx_py3_none_any_09719015\":[{\"filename\":\"sphinx-8.1.3-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "sphinx_autodoc2": "{\"dev_pip_311_sphinx_autodoc2_py3_none_any_e867013b\":[{\"filename\":\"sphinx_autodoc2-0.5.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinx_autodoc2_py3_none_any_e867013b\":[{\"filename\":\"sphinx_autodoc2-0.5.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "sphinx_reredirects": "{\"dev_pip_311_sphinx_reredirects_py3_none_any_444ae143\":[{\"filename\":\"sphinx_reredirects-0.1.5-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinx_reredirects_py3_none_any_444ae143\":[{\"filename\":\"sphinx_reredirects-0.1.5-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "sphinx_rtd_theme": "{\"dev_pip_311_sphinx_rtd_theme_py2_none_any_921c0ece\":[{\"filename\":\"sphinx_rtd_theme-3.0.1-py2.py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinx_rtd_theme_py2_none_any_921c0ece\":[{\"filename\":\"sphinx_rtd_theme-3.0.1-py2.py3-none-any.whl\",\"version\":\"3.13\"}]}", - "sphinxcontrib_applehelp": "{\"dev_pip_311_sphinxcontrib_applehelp_py3_none_any_4cd3f0ec\":[{\"filename\":\"sphinxcontrib_applehelp-2.0.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinxcontrib_applehelp_py3_none_any_4cd3f0ec\":[{\"filename\":\"sphinxcontrib_applehelp-2.0.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "sphinxcontrib_devhelp": "{\"dev_pip_311_sphinxcontrib_devhelp_py3_none_any_aefb8b83\":[{\"filename\":\"sphinxcontrib_devhelp-2.0.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinxcontrib_devhelp_py3_none_any_aefb8b83\":[{\"filename\":\"sphinxcontrib_devhelp-2.0.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "sphinxcontrib_htmlhelp": "{\"dev_pip_311_sphinxcontrib_htmlhelp_py3_none_any_16675982\":[{\"filename\":\"sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinxcontrib_htmlhelp_py3_none_any_16675982\":[{\"filename\":\"sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "sphinxcontrib_jquery": "{\"dev_pip_311_sphinxcontrib_jquery_py2_none_any_f936030d\":[{\"filename\":\"sphinxcontrib_jquery-4.1-py2.py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinxcontrib_jquery_py2_none_any_f936030d\":[{\"filename\":\"sphinxcontrib_jquery-4.1-py2.py3-none-any.whl\",\"version\":\"3.13\"}]}", - "sphinxcontrib_jsmath": "{\"dev_pip_311_sphinxcontrib_jsmath_py2_none_any_2ec2eaeb\":[{\"filename\":\"sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinxcontrib_jsmath_py2_none_any_2ec2eaeb\":[{\"filename\":\"sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl\",\"version\":\"3.13\"}]}", - "sphinxcontrib_qthelp": "{\"dev_pip_311_sphinxcontrib_qthelp_py3_none_any_b18a828c\":[{\"filename\":\"sphinxcontrib_qthelp-2.0.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinxcontrib_qthelp_py3_none_any_b18a828c\":[{\"filename\":\"sphinxcontrib_qthelp-2.0.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "sphinxcontrib_serializinghtml": "{\"dev_pip_311_sphinxcontrib_serializinghtml_py3_none_any_6e2cb0ee\":[{\"filename\":\"sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_sphinxcontrib_serializinghtml_py3_none_any_6e2cb0ee\":[{\"filename\":\"sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "typing_extensions": "{\"dev_pip_311_typing_extensions_py3_none_any_04e5ca03\":[{\"filename\":\"typing_extensions-4.12.2-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_typing_extensions_py3_none_any_04e5ca03\":[{\"filename\":\"typing_extensions-4.12.2-py3-none-any.whl\",\"version\":\"3.13\"}]}", - "urllib3": "{\"dev_pip_311_urllib3_py3_none_any_ca899ca0\":[{\"filename\":\"urllib3-2.2.3-py3-none-any.whl\",\"version\":\"3.11\"}],\"dev_pip_313_urllib3_py3_none_any_ca899ca0\":[{\"filename\":\"urllib3-2.2.3-py3-none-any.whl\",\"version\":\"3.13\"}]}" - }, - "packages": [ - "absl_py", - "alabaster", - "astroid", - "babel", - "certifi", - "charset_normalizer", - "docutils", - "idna", - "imagesize", - "jinja2", - "markdown_it_py", - "markupsafe", - "mdit_py_plugins", - "mdurl", - "myst_parser", - "packaging", - "pygments", - "pyyaml", - "readthedocs_sphinx_ext", - "requests", - "snowballstemmer", - "sphinx", - "sphinx_autodoc2", - "sphinx_reredirects", - "sphinx_rtd_theme", - "sphinxcontrib_applehelp", - "sphinxcontrib_devhelp", - "sphinxcontrib_htmlhelp", - "sphinxcontrib_jquery", - "sphinxcontrib_jsmath", - "sphinxcontrib_qthelp", - "sphinxcontrib_serializinghtml", - "typing_extensions", - "urllib3" - ], - "groups": {} - } - }, - "pip_deps": { - "repoRuleId": "@@//python/private/pypi:hub_repository.bzl%hub_repository", - "attributes": { - "repo_name": "pip_deps", - "extra_hub_aliases": {}, - "whl_map": { - "numpy": "{\"pip_deps_310_numpy\":[{\"version\":\"3.10\"}],\"pip_deps_311_numpy\":[{\"version\":\"3.11\"}],\"pip_deps_312_numpy\":[{\"version\":\"3.12\"}],\"pip_deps_38_numpy\":[{\"version\":\"3.8\"}],\"pip_deps_39_numpy\":[{\"version\":\"3.9\"}]}", - "setuptools": "{\"pip_deps_310_setuptools\":[{\"version\":\"3.10\"}],\"pip_deps_311_setuptools\":[{\"version\":\"3.11\"}],\"pip_deps_312_setuptools\":[{\"version\":\"3.12\"}],\"pip_deps_38_setuptools\":[{\"version\":\"3.8\"}],\"pip_deps_39_setuptools\":[{\"version\":\"3.9\"}]}" - }, - "packages": [ - "numpy", - "setuptools" - ], - "groups": {} - } - }, - "pypiserver": { - "repoRuleId": "@@//python/private/pypi:hub_repository.bzl%hub_repository", - "attributes": { - "repo_name": "pypiserver", - "extra_hub_aliases": {}, - "whl_map": { - "pip": "{\"pypiserver_311_pip_py3_none_any_ba0d021a\":[{\"filename\":\"pip-24.0-py3-none-any.whl\",\"version\":\"3.11\"}]}", - "pypiserver": "{\"pypiserver_311_pypiserver_py2_none_any_1dd98fb9\":[{\"filename\":\"pypiserver-2.0.1-py2.py3-none-any.whl\",\"version\":\"3.11\"}]}" - }, - "packages": [ - "pip", - "pypiserver" - ], - "groups": {} - } - }, - "rules_fuzzing_py_deps": { - "repoRuleId": "@@//python/private/pypi:hub_repository.bzl%hub_repository", - "attributes": { - "repo_name": "rules_fuzzing_py_deps", - "extra_hub_aliases": {}, - "whl_map": { - "absl_py": "{\"rules_fuzzing_py_deps_310_absl_py\":[{\"version\":\"3.10\"}],\"rules_fuzzing_py_deps_311_absl_py\":[{\"version\":\"3.11\"}],\"rules_fuzzing_py_deps_312_absl_py\":[{\"version\":\"3.12\"}],\"rules_fuzzing_py_deps_38_absl_py\":[{\"version\":\"3.8\"}],\"rules_fuzzing_py_deps_39_absl_py\":[{\"version\":\"3.9\"}]}", - "six": "{\"rules_fuzzing_py_deps_310_six\":[{\"version\":\"3.10\"}],\"rules_fuzzing_py_deps_311_six\":[{\"version\":\"3.11\"}],\"rules_fuzzing_py_deps_312_six\":[{\"version\":\"3.12\"}],\"rules_fuzzing_py_deps_38_six\":[{\"version\":\"3.8\"}],\"rules_fuzzing_py_deps_39_six\":[{\"version\":\"3.9\"}]}" - }, - "packages": [ - "absl_py", - "six" - ], - "groups": {} - } - }, - "rules_python_publish_deps": { - "repoRuleId": "@@//python/private/pypi:hub_repository.bzl%hub_repository", - "attributes": { - "repo_name": "rules_python_publish_deps", - "extra_hub_aliases": {}, - "whl_map": { - "backports_tarfile": "{\"rules_python_publish_deps_311_backports_tarfile_py3_none_any_77e284d7\":[{\"filename\":\"backports.tarfile-1.2.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_backports_tarfile_sdist_d75e02c2\":[{\"filename\":\"backports_tarfile-1.2.0.tar.gz\",\"version\":\"3.11\"}]}", - "certifi": "{\"rules_python_publish_deps_311_certifi_py3_none_any_922820b5\":[{\"filename\":\"certifi-2024.8.30-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_certifi_sdist_bec941d2\":[{\"filename\":\"certifi-2024.8.30.tar.gz\",\"version\":\"3.11\"}]}", - "cffi": "{\"rules_python_publish_deps_311_cffi_cp311_cp311_manylinux_2_17_aarch64_a1ed2dd2\":[{\"filename\":\"cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cffi_cp311_cp311_manylinux_2_17_ppc64le_46bf4316\":[{\"filename\":\"cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cffi_cp311_cp311_manylinux_2_17_s390x_a24ed04c\":[{\"filename\":\"cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cffi_cp311_cp311_manylinux_2_17_x86_64_610faea7\":[{\"filename\":\"cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cffi_cp311_cp311_musllinux_1_1_aarch64_a9b15d49\":[{\"filename\":\"cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cffi_cp311_cp311_musllinux_1_1_x86_64_fc48c783\":[{\"filename\":\"cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cffi_sdist_1c39c601\":[{\"filename\":\"cffi-1.17.1.tar.gz\",\"version\":\"3.11\"}]}", - "charset_normalizer": "{\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_macosx_10_9_universal2_0d99dd8f\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_macosx_10_9_x86_64_c57516e5\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_macosx_11_0_arm64_6dba5d19\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_manylinux_2_17_aarch64_bf4475b8\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_manylinux_2_17_ppc64le_ce031db0\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_manylinux_2_17_s390x_8ff4e7cd\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_manylinux_2_17_x86_64_3710a975\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_musllinux_1_2_aarch64_47334db7\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_musllinux_1_2_ppc64le_f1a2f519\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_musllinux_1_2_s390x_63bc5c4a\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_musllinux_1_2_x86_64_bcb4f8ea\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_cp311_cp311_win_amd64_cee4373f\":[{\"filename\":\"charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_py3_none_any_fe9f97fe\":[{\"filename\":\"charset_normalizer-3.4.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_charset_normalizer_sdist_223217c3\":[{\"filename\":\"charset_normalizer-3.4.0.tar.gz\",\"version\":\"3.11\"}]}", - "cryptography": "{\"rules_python_publish_deps_311_cryptography_cp39_abi3_manylinux_2_17_aarch64_846da004\":[{\"filename\":\"cryptography-43.0.3-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cryptography_cp39_abi3_manylinux_2_17_x86_64_0f996e72\":[{\"filename\":\"cryptography-43.0.3-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cryptography_cp39_abi3_manylinux_2_28_aarch64_f7b178f1\":[{\"filename\":\"cryptography-43.0.3-cp39-abi3-manylinux_2_28_aarch64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cryptography_cp39_abi3_manylinux_2_28_x86_64_c2e6fc39\":[{\"filename\":\"cryptography-43.0.3-cp39-abi3-manylinux_2_28_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cryptography_cp39_abi3_musllinux_1_2_aarch64_e1be4655\":[{\"filename\":\"cryptography-43.0.3-cp39-abi3-musllinux_1_2_aarch64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cryptography_cp39_abi3_musllinux_1_2_x86_64_df6b6c6d\":[{\"filename\":\"cryptography-43.0.3-cp39-abi3-musllinux_1_2_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_cryptography_sdist_315b9001\":[{\"filename\":\"cryptography-43.0.3.tar.gz\",\"version\":\"3.11\"}]}", - "docutils": "{\"rules_python_publish_deps_311_docutils_py3_none_any_dafca5b9\":[{\"filename\":\"docutils-0.21.2-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_docutils_sdist_3a6b1873\":[{\"filename\":\"docutils-0.21.2.tar.gz\",\"version\":\"3.11\"}]}", - "idna": "{\"rules_python_publish_deps_311_idna_py3_none_any_946d195a\":[{\"filename\":\"idna-3.10-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_idna_sdist_12f65c9b\":[{\"filename\":\"idna-3.10.tar.gz\",\"version\":\"3.11\"}]}", - "importlib_metadata": "{\"rules_python_publish_deps_311_importlib_metadata_py3_none_any_45e54197\":[{\"filename\":\"importlib_metadata-8.5.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_importlib_metadata_sdist_71522656\":[{\"filename\":\"importlib_metadata-8.5.0.tar.gz\",\"version\":\"3.11\"}]}", - "jaraco_classes": "{\"rules_python_publish_deps_311_jaraco_classes_py3_none_any_f662826b\":[{\"filename\":\"jaraco.classes-3.4.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_jaraco_classes_sdist_47a024b5\":[{\"filename\":\"jaraco.classes-3.4.0.tar.gz\",\"version\":\"3.11\"}]}", - "jaraco_context": "{\"rules_python_publish_deps_311_jaraco_context_py3_none_any_f797fc48\":[{\"filename\":\"jaraco.context-6.0.1-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_jaraco_context_sdist_9bae4ea5\":[{\"filename\":\"jaraco_context-6.0.1.tar.gz\",\"version\":\"3.11\"}]}", - "jaraco_functools": "{\"rules_python_publish_deps_311_jaraco_functools_py3_none_any_ad159f13\":[{\"filename\":\"jaraco.functools-4.1.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_jaraco_functools_sdist_70f7e0e2\":[{\"filename\":\"jaraco_functools-4.1.0.tar.gz\",\"version\":\"3.11\"}]}", - "jeepney": "{\"rules_python_publish_deps_311_jeepney_py3_none_any_c0a454ad\":[{\"filename\":\"jeepney-0.8.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_jeepney_sdist_5efe48d2\":[{\"filename\":\"jeepney-0.8.0.tar.gz\",\"version\":\"3.11\"}]}", - "keyring": "{\"rules_python_publish_deps_311_keyring_py3_none_any_5426f817\":[{\"filename\":\"keyring-25.4.1-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_keyring_sdist_b07ebc55\":[{\"filename\":\"keyring-25.4.1.tar.gz\",\"version\":\"3.11\"}]}", - "markdown_it_py": "{\"rules_python_publish_deps_311_markdown_it_py_py3_none_any_35521684\":[{\"filename\":\"markdown_it_py-3.0.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_markdown_it_py_sdist_e3f60a94\":[{\"filename\":\"markdown-it-py-3.0.0.tar.gz\",\"version\":\"3.11\"}]}", - "mdurl": "{\"rules_python_publish_deps_311_mdurl_py3_none_any_84008a41\":[{\"filename\":\"mdurl-0.1.2-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_mdurl_sdist_bb413d29\":[{\"filename\":\"mdurl-0.1.2.tar.gz\",\"version\":\"3.11\"}]}", - "more_itertools": "{\"rules_python_publish_deps_311_more_itertools_py3_none_any_037b0d32\":[{\"filename\":\"more_itertools-10.5.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_more_itertools_sdist_5482bfef\":[{\"filename\":\"more-itertools-10.5.0.tar.gz\",\"version\":\"3.11\"}]}", - "nh3": "{\"rules_python_publish_deps_311_nh3_cp37_abi3_macosx_10_12_x86_64_14c5a72e\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_macosx_10_12_x86_64_7b7c2a3c\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-macosx_10_12_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_aarch64_42c64511\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_armv7l_0411beb0\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_ppc64_5f36b271\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-manylinux_2_17_ppc64.manylinux2014_ppc64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_ppc64le_34c03fa7\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_s390x_19aaba96\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_manylinux_2_17_x86_64_de3ceed6\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_musllinux_1_2_aarch64_f0eca9ca\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-musllinux_1_2_aarch64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_musllinux_1_2_armv7l_3a157ab1\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-musllinux_1_2_armv7l.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_musllinux_1_2_x86_64_36c95d4b\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-musllinux_1_2_x86_64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_cp37_abi3_win_amd64_8ce0f819\":[{\"filename\":\"nh3-0.2.18-cp37-abi3-win_amd64.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_nh3_sdist_94a16692\":[{\"filename\":\"nh3-0.2.18.tar.gz\",\"version\":\"3.11\"}]}", - "pkginfo": "{\"rules_python_publish_deps_311_pkginfo_py3_none_any_889a6da2\":[{\"filename\":\"pkginfo-1.10.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_pkginfo_sdist_5df73835\":[{\"filename\":\"pkginfo-1.10.0.tar.gz\",\"version\":\"3.11\"}]}", - "pycparser": "{\"rules_python_publish_deps_311_pycparser_py3_none_any_c3702b6d\":[{\"filename\":\"pycparser-2.22-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_pycparser_sdist_491c8be9\":[{\"filename\":\"pycparser-2.22.tar.gz\",\"version\":\"3.11\"}]}", - "pygments": "{\"rules_python_publish_deps_311_pygments_py3_none_any_b8e6aca0\":[{\"filename\":\"pygments-2.18.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_pygments_sdist_786ff802\":[{\"filename\":\"pygments-2.18.0.tar.gz\",\"version\":\"3.11\"}]}", - "pywin32_ctypes": "{\"rules_python_publish_deps_311_pywin32_ctypes_py3_none_any_8a151337\":[{\"filename\":\"pywin32_ctypes-0.2.3-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_pywin32_ctypes_sdist_d162dc04\":[{\"filename\":\"pywin32-ctypes-0.2.3.tar.gz\",\"version\":\"3.11\"}]}", - "readme_renderer": "{\"rules_python_publish_deps_311_readme_renderer_py3_none_any_2fbca89b\":[{\"filename\":\"readme_renderer-44.0-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_readme_renderer_sdist_8712034e\":[{\"filename\":\"readme_renderer-44.0.tar.gz\",\"version\":\"3.11\"}]}", - "requests": "{\"rules_python_publish_deps_311_requests_py3_none_any_70761cfe\":[{\"filename\":\"requests-2.32.3-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_requests_sdist_55365417\":[{\"filename\":\"requests-2.32.3.tar.gz\",\"version\":\"3.11\"}]}", - "requests_toolbelt": "{\"rules_python_publish_deps_311_requests_toolbelt_py2_none_any_cccfdd66\":[{\"filename\":\"requests_toolbelt-1.0.0-py2.py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_requests_toolbelt_sdist_7681a0a3\":[{\"filename\":\"requests-toolbelt-1.0.0.tar.gz\",\"version\":\"3.11\"}]}", - "rfc3986": "{\"rules_python_publish_deps_311_rfc3986_py2_none_any_50b1502b\":[{\"filename\":\"rfc3986-2.0.0-py2.py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_rfc3986_sdist_97aacf9d\":[{\"filename\":\"rfc3986-2.0.0.tar.gz\",\"version\":\"3.11\"}]}", - "rich": "{\"rules_python_publish_deps_311_rich_py3_none_any_6049d5e6\":[{\"filename\":\"rich-13.9.4-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_rich_sdist_43959497\":[{\"filename\":\"rich-13.9.4.tar.gz\",\"version\":\"3.11\"}]}", - "secretstorage": "{\"rules_python_publish_deps_311_secretstorage_py3_none_any_f356e662\":[{\"filename\":\"SecretStorage-3.3.3-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_secretstorage_sdist_2403533e\":[{\"filename\":\"SecretStorage-3.3.3.tar.gz\",\"version\":\"3.11\"}]}", - "twine": "{\"rules_python_publish_deps_311_twine_py3_none_any_215dbe7b\":[{\"filename\":\"twine-5.1.1-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_twine_sdist_9aa08251\":[{\"filename\":\"twine-5.1.1.tar.gz\",\"version\":\"3.11\"}]}", - "urllib3": "{\"rules_python_publish_deps_311_urllib3_py3_none_any_ca899ca0\":[{\"filename\":\"urllib3-2.2.3-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_urllib3_sdist_e7d814a8\":[{\"filename\":\"urllib3-2.2.3.tar.gz\",\"version\":\"3.11\"}]}", - "zipp": "{\"rules_python_publish_deps_311_zipp_py3_none_any_a817ac80\":[{\"filename\":\"zipp-3.20.2-py3-none-any.whl\",\"version\":\"3.11\"}],\"rules_python_publish_deps_311_zipp_sdist_bc9eb26f\":[{\"filename\":\"zipp-3.20.2.tar.gz\",\"version\":\"3.11\"}]}" - }, - "packages": [ - "backports_tarfile", - "certifi", - "charset_normalizer", - "docutils", - "idna", - "importlib_metadata", - "jaraco_classes", - "jaraco_context", - "jaraco_functools", - "keyring", - "markdown_it_py", - "mdurl", - "more_itertools", - "nh3", - "pkginfo", - "pygments", - "readme_renderer", - "requests", - "requests_toolbelt", - "rfc3986", - "rich", - "twine", - "urllib3", - "zipp" - ], - "groups": {} - } - } - }, - "moduleExtensionMetadata": { - "useAllRepos": "NO", - "reproducible": false - }, - "recordedRepoMappingEntries": [ - [ - "", - "bazel_features", - "bazel_features+" - ], - [ - "", - "bazel_skylib", - "bazel_skylib+" - ], - [ - "", - "bazel_tools", - "bazel_tools" - ], - [ - "", - "pypi__build", - "+internal_deps+pypi__build" - ], - [ - "", - "pypi__click", - "+internal_deps+pypi__click" - ], - [ - "", - "pypi__colorama", - "+internal_deps+pypi__colorama" - ], - [ - "", - "pypi__importlib_metadata", - "+internal_deps+pypi__importlib_metadata" - ], - [ - "", - "pypi__installer", - "+internal_deps+pypi__installer" - ], - [ - "", - "pypi__more_itertools", - "+internal_deps+pypi__more_itertools" - ], - [ - "", - "pypi__packaging", - "+internal_deps+pypi__packaging" - ], - [ - "", - "pypi__pep517", - "+internal_deps+pypi__pep517" - ], - [ - "", - "pypi__pip", - "+internal_deps+pypi__pip" - ], - [ - "", - "pypi__pip_tools", - "+internal_deps+pypi__pip_tools" - ], - [ - "", - "pypi__pyproject_hooks", - "+internal_deps+pypi__pyproject_hooks" - ], - [ - "", - "pypi__setuptools", - "+internal_deps+pypi__setuptools" - ], - [ - "", - "pypi__tomli", - "+internal_deps+pypi__tomli" - ], - [ - "", - "pypi__wheel", - "+internal_deps+pypi__wheel" - ], - [ - "", - "pypi__zipp", - "+internal_deps+pypi__zipp" - ], - [ - "", - "pythons_hub", - "+python+pythons_hub" - ], - [ - "+python+pythons_hub", - "python_3_10_11_host", - "+python+python_3_10_11_host" - ], - [ - "+python+pythons_hub", - "python_3_10_12_host", - "+python+python_3_10_12_host" - ], - [ - "+python+pythons_hub", - "python_3_10_13_host", - "+python+python_3_10_13_host" - ], - [ - "+python+pythons_hub", - "python_3_10_14_host", - "+python+python_3_10_14_host" - ], - [ - "+python+pythons_hub", - "python_3_10_15_host", - "+python+python_3_10_15_host" - ], - [ - "+python+pythons_hub", - "python_3_10_16_host", - "+python+python_3_10_16_host" - ], - [ - "+python+pythons_hub", - "python_3_10_2_host", - "+python+python_3_10_2_host" - ], - [ - "+python+pythons_hub", - "python_3_10_4_host", - "+python+python_3_10_4_host" - ], - [ - "+python+pythons_hub", - "python_3_10_6_host", - "+python+python_3_10_6_host" - ], - [ - "+python+pythons_hub", - "python_3_10_8_host", - "+python+python_3_10_8_host" - ], - [ - "+python+pythons_hub", - "python_3_10_9_host", - "+python+python_3_10_9_host" - ], - [ - "+python+pythons_hub", - "python_3_10_host", - "+python+python_3_10_host" - ], - [ - "+python+pythons_hub", - "python_3_11_10_host", - "+python+python_3_11_10_host" - ], - [ - "+python+pythons_hub", - "python_3_11_11_host", - "+python+python_3_11_11_host" - ], - [ - "+python+pythons_hub", - "python_3_11_1_host", - "+python+python_3_11_1_host" - ], - [ - "+python+pythons_hub", - "python_3_11_3_host", - "+python+python_3_11_3_host" - ], - [ - "+python+pythons_hub", - "python_3_11_4_host", - "+python+python_3_11_4_host" - ], - [ - "+python+pythons_hub", - "python_3_11_5_host", - "+python+python_3_11_5_host" - ], - [ - "+python+pythons_hub", - "python_3_11_6_host", - "+python+python_3_11_6_host" - ], - [ - "+python+pythons_hub", - "python_3_11_7_host", - "+python+python_3_11_7_host" - ], - [ - "+python+pythons_hub", - "python_3_11_8_host", - "+python+python_3_11_8_host" - ], - [ - "+python+pythons_hub", - "python_3_11_9_host", - "+python+python_3_11_9_host" - ], - [ - "+python+pythons_hub", - "python_3_11_host", - "+python+python_3_11_host" - ], - [ - "+python+pythons_hub", - "python_3_12_0_host", - "+python+python_3_12_0_host" - ], - [ - "+python+pythons_hub", - "python_3_12_1_host", - "+python+python_3_12_1_host" - ], - [ - "+python+pythons_hub", - "python_3_12_2_host", - "+python+python_3_12_2_host" - ], - [ - "+python+pythons_hub", - "python_3_12_3_host", - "+python+python_3_12_3_host" - ], - [ - "+python+pythons_hub", - "python_3_12_4_host", - "+python+python_3_12_4_host" - ], - [ - "+python+pythons_hub", - "python_3_12_7_host", - "+python+python_3_12_7_host" - ], - [ - "+python+pythons_hub", - "python_3_12_8_host", - "+python+python_3_12_8_host" - ], - [ - "+python+pythons_hub", - "python_3_12_host", - "+python+python_3_12_host" - ], - [ - "+python+pythons_hub", - "python_3_13_0_host", - "+python+python_3_13_0_host" - ], - [ - "+python+pythons_hub", - "python_3_13_1_host", - "+python+python_3_13_1_host" - ], - [ - "+python+pythons_hub", - "python_3_13_host", - "+python+python_3_13_host" - ], - [ - "+python+pythons_hub", - "python_3_8_10_host", - "+python+python_3_8_10_host" - ], - [ - "+python+pythons_hub", - "python_3_8_12_host", - "+python+python_3_8_12_host" - ], - [ - "+python+pythons_hub", - "python_3_8_13_host", - "+python+python_3_8_13_host" - ], - [ - "+python+pythons_hub", - "python_3_8_15_host", - "+python+python_3_8_15_host" - ], - [ - "+python+pythons_hub", - "python_3_8_16_host", - "+python+python_3_8_16_host" - ], - [ - "+python+pythons_hub", - "python_3_8_17_host", - "+python+python_3_8_17_host" - ], - [ - "+python+pythons_hub", - "python_3_8_18_host", - "+python+python_3_8_18_host" - ], - [ - "+python+pythons_hub", - "python_3_8_19_host", - "+python+python_3_8_19_host" - ], - [ - "+python+pythons_hub", - "python_3_8_20_host", - "+python+python_3_8_20_host" - ], - [ - "+python+pythons_hub", - "python_3_8_host", - "+python+python_3_8_host" - ], - [ - "+python+pythons_hub", - "python_3_9_10_host", - "+python+python_3_9_10_host" - ], - [ - "+python+pythons_hub", - "python_3_9_12_host", - "+python+python_3_9_12_host" - ], - [ - "+python+pythons_hub", - "python_3_9_13_host", - "+python+python_3_9_13_host" - ], - [ - "+python+pythons_hub", - "python_3_9_15_host", - "+python+python_3_9_15_host" - ], - [ - "+python+pythons_hub", - "python_3_9_16_host", - "+python+python_3_9_16_host" - ], - [ - "+python+pythons_hub", - "python_3_9_17_host", - "+python+python_3_9_17_host" - ], - [ - "+python+pythons_hub", - "python_3_9_18_host", - "+python+python_3_9_18_host" - ], - [ - "+python+pythons_hub", - "python_3_9_19_host", - "+python+python_3_9_19_host" - ], - [ - "+python+pythons_hub", - "python_3_9_20_host", - "+python+python_3_9_20_host" - ], - [ - "+python+pythons_hub", - "python_3_9_21_host", - "+python+python_3_9_21_host" - ], - [ - "+python+pythons_hub", - "python_3_9_host", - "+python+python_3_9_host" - ], - [ - "bazel_features+", - "bazel_features_globals", - "bazel_features++version_extension+bazel_features_globals" - ], - [ - "bazel_features+", - "bazel_features_version", - "bazel_features++version_extension+bazel_features_version" - ] - ] - } - }, - "//python/uv:uv.bzl%uv": { - "general": { - "bzlTransitiveDigest": "DjpJ/IIJl51GG3GQ84gJ20+o2twqsRYNdLHyQJ/OsTQ=", - "usagesDigest": "IBWFhCxATF6PNVT9Z6OyNYwgyK7EktkyRLKaoMPa/yw=", - "recordedFileInputs": {}, - "recordedDirentsInputs": {}, - "envVariables": {}, - "generatedRepoSpecs": { - "uv_darwin_aarch64": { - "repoRuleId": "@@//python/uv/private:uv_repositories.bzl%uv_repository", - "attributes": { - "uv_version": "0.4.25", - "platform": "aarch64-apple-darwin" - } - }, - "uv_linux_aarch64": { - "repoRuleId": "@@//python/uv/private:uv_repositories.bzl%uv_repository", - "attributes": { - "uv_version": "0.4.25", - "platform": "aarch64-unknown-linux-gnu" - } - }, - "uv_linux_ppc": { - "repoRuleId": "@@//python/uv/private:uv_repositories.bzl%uv_repository", - "attributes": { - "uv_version": "0.4.25", - "platform": "powerpc64le-unknown-linux-gnu" - } - }, - "uv_linux_s390x": { - "repoRuleId": "@@//python/uv/private:uv_repositories.bzl%uv_repository", - "attributes": { - "uv_version": "0.4.25", - "platform": "s390x-unknown-linux-gnu" - } - }, - "uv_darwin_x86_64": { - "repoRuleId": "@@//python/uv/private:uv_repositories.bzl%uv_repository", - "attributes": { - "uv_version": "0.4.25", - "platform": "x86_64-apple-darwin" - } - }, - "uv_windows_x86_64": { - "repoRuleId": "@@//python/uv/private:uv_repositories.bzl%uv_repository", - "attributes": { - "uv_version": "0.4.25", - "platform": "x86_64-pc-windows-msvc" - } - }, - "uv_linux_x86_64": { - "repoRuleId": "@@//python/uv/private:uv_repositories.bzl%uv_repository", - "attributes": { - "uv_version": "0.4.25", - "platform": "x86_64-unknown-linux-gnu" - } - }, - "uv_toolchains": { - "repoRuleId": "@@//python/uv/private:uv_toolchains_repo.bzl%uv_toolchains_repo", - "attributes": { - "toolchain_type": "'@@//python/uv:uv_toolchain_type'", - "toolchain_names": [ - "uv_darwin_aarch64_toolchain", - "uv_linux_aarch64_toolchain", - "uv_linux_ppc_toolchain", - "uv_linux_s390x_toolchain", - "uv_darwin_x86_64_toolchain", - "uv_windows_x86_64_toolchain", - "uv_linux_x86_64_toolchain" - ], - "toolchain_labels": { - "uv_darwin_aarch64_toolchain": "@uv_darwin_aarch64//:uv_toolchain", - "uv_linux_aarch64_toolchain": "@uv_linux_aarch64//:uv_toolchain", - "uv_linux_ppc_toolchain": "@uv_linux_ppc//:uv_toolchain", - "uv_linux_s390x_toolchain": "@uv_linux_s390x//:uv_toolchain", - "uv_darwin_x86_64_toolchain": "@uv_darwin_x86_64//:uv_toolchain", - "uv_windows_x86_64_toolchain": "@uv_windows_x86_64//:uv_toolchain", - "uv_linux_x86_64_toolchain": "@uv_linux_x86_64//:uv_toolchain" - }, - "toolchain_compatible_with": { - "uv_darwin_aarch64_toolchain": [ - "@platforms//os:macos", - "@platforms//cpu:aarch64" - ], - "uv_linux_aarch64_toolchain": [ - "@platforms//os:linux", - "@platforms//cpu:aarch64" - ], - "uv_linux_ppc_toolchain": [ - "@platforms//os:linux", - "@platforms//cpu:ppc" - ], - "uv_linux_s390x_toolchain": [ - "@platforms//os:linux", - "@platforms//cpu:s390x" - ], - "uv_darwin_x86_64_toolchain": [ - "@platforms//os:macos", - "@platforms//cpu:x86_64" - ], - "uv_windows_x86_64_toolchain": [ - "@platforms//os:windows", - "@platforms//cpu:x86_64" - ], - "uv_linux_x86_64_toolchain": [ - "@platforms//os:linux", - "@platforms//cpu:x86_64" - ] - } - } - } - }, - "recordedRepoMappingEntries": [] - } - }, - "@@buildifier_prebuilt+//:defs.bzl%buildifier_prebuilt_deps_extension": { - "general": { - "bzlTransitiveDigest": "BQ67MS38sDZxeQEfUs4vghLhs3+m4IXU/i7XC50fl9s=", - "usagesDigest": "JCqhJg+TeFVLBlrKVGI0Npi9RChNqkZQAh9TYfbAobs=", - "recordedFileInputs": {}, - "recordedDirentsInputs": {}, - "envVariables": {}, - "generatedRepoSpecs": { - "buildifier_darwin_amd64": { - "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", - "attributes": { - "urls": [ - "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildifier-darwin-amd64" - ], - "downloaded_file_path": "buildifier", - "executable": true, - "sha256": "e2f4a67691c5f55634fbfb3850eb97dd91be0edd059d947b6c83d120682e0216" - } - }, - "buildifier_darwin_arm64": { - "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", - "attributes": { - "urls": [ - "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildifier-darwin-arm64" - ], - "downloaded_file_path": "buildifier", - "executable": true, - "sha256": "7549b5f535219ac957aa2a6069d46fbfc9ea3f74abd85fd3d460af4b1a2099a6" - } - }, - "buildifier_linux_amd64": { - "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", - "attributes": { - "urls": [ - "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildifier-linux-amd64" - ], - "downloaded_file_path": "buildifier", - "executable": true, - "sha256": "51bc947dabb7b14ec6fb1224464fbcf7a7cb138f1a10a3b328f00835f72852ce" - } - }, - "buildifier_linux_arm64": { - "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", - "attributes": { - "urls": [ - "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildifier-linux-arm64" - ], - "downloaded_file_path": "buildifier", - "executable": true, - "sha256": "0ba6e8e3208b5a029164e542ddb5509e618f87b639ffe8cc2f54770022853080" - } - }, - "buildifier_windows_amd64": { - "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", - "attributes": { - "urls": [ - "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildifier-windows-amd64.exe" - ], - "downloaded_file_path": "buildifier.exe", - "executable": true, - "sha256": "92bdd284fbc6766fc3e300b434ff9e68ac4d76a06cb29d1bdefe79a102a8d135" - } - }, - "buildozer_darwin_amd64": { - "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", - "attributes": { - "urls": [ - "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildozer-darwin-amd64" - ], - "downloaded_file_path": "buildozer", - "executable": true, - "sha256": "4014751a4cc5e91a7dc4b64be7b30c565bd9014ae6d1879818dc624562a1d431" - } - }, - "buildozer_darwin_arm64": { - "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", - "attributes": { - "urls": [ - "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildozer-darwin-arm64" - ], - "downloaded_file_path": "buildozer", - "executable": true, - "sha256": "e78bd5357f2356067d4b0d49ec4e4143dd9b1308746afc6ff11b55b952f462d7" - } - }, - "buildozer_linux_amd64": { - "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", - "attributes": { - "urls": [ - "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildozer-linux-amd64" - ], - "downloaded_file_path": "buildozer", - "executable": true, - "sha256": "2aef0f1ef80a0140b8fe6e6a8eb822e14827d8855bfc6681532c7530339ea23b" - } - }, - "buildozer_linux_arm64": { - "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", - "attributes": { - "urls": [ - "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildozer-linux-arm64" - ], - "downloaded_file_path": "buildozer", - "executable": true, - "sha256": "586e27630cbc242e8bd6fe8e24485eca8dcadea6410cc13cbe059202655980ac" - } - }, - "buildozer_windows_amd64": { - "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", - "attributes": { - "urls": [ - "https://github.com/bazelbuild/buildtools/releases/download/v6.1.2/buildozer-windows-amd64.exe" - ], - "downloaded_file_path": "buildozer.exe", - "executable": true, - "sha256": "07664d5d08ee099f069cd654070cabf2708efaae9f52dc83921fa400c67a868b" - } - }, - "buildifier_prebuilt_toolchains": { - "repoRuleId": "@@buildifier_prebuilt+//:defs.bzl%_buildifier_toolchain_setup", - "attributes": { - "assets_json": "[{\"arch\":\"amd64\",\"name\":\"buildifier\",\"platform\":\"darwin\",\"sha256\":\"e2f4a67691c5f55634fbfb3850eb97dd91be0edd059d947b6c83d120682e0216\",\"version\":\"v6.1.2\"},{\"arch\":\"arm64\",\"name\":\"buildifier\",\"platform\":\"darwin\",\"sha256\":\"7549b5f535219ac957aa2a6069d46fbfc9ea3f74abd85fd3d460af4b1a2099a6\",\"version\":\"v6.1.2\"},{\"arch\":\"amd64\",\"name\":\"buildifier\",\"platform\":\"linux\",\"sha256\":\"51bc947dabb7b14ec6fb1224464fbcf7a7cb138f1a10a3b328f00835f72852ce\",\"version\":\"v6.1.2\"},{\"arch\":\"arm64\",\"name\":\"buildifier\",\"platform\":\"linux\",\"sha256\":\"0ba6e8e3208b5a029164e542ddb5509e618f87b639ffe8cc2f54770022853080\",\"version\":\"v6.1.2\"},{\"arch\":\"amd64\",\"name\":\"buildifier\",\"platform\":\"windows\",\"sha256\":\"92bdd284fbc6766fc3e300b434ff9e68ac4d76a06cb29d1bdefe79a102a8d135\",\"version\":\"v6.1.2\"},{\"arch\":\"amd64\",\"name\":\"buildozer\",\"platform\":\"darwin\",\"sha256\":\"4014751a4cc5e91a7dc4b64be7b30c565bd9014ae6d1879818dc624562a1d431\",\"version\":\"v6.1.2\"},{\"arch\":\"arm64\",\"name\":\"buildozer\",\"platform\":\"darwin\",\"sha256\":\"e78bd5357f2356067d4b0d49ec4e4143dd9b1308746afc6ff11b55b952f462d7\",\"version\":\"v6.1.2\"},{\"arch\":\"amd64\",\"name\":\"buildozer\",\"platform\":\"linux\",\"sha256\":\"2aef0f1ef80a0140b8fe6e6a8eb822e14827d8855bfc6681532c7530339ea23b\",\"version\":\"v6.1.2\"},{\"arch\":\"arm64\",\"name\":\"buildozer\",\"platform\":\"linux\",\"sha256\":\"586e27630cbc242e8bd6fe8e24485eca8dcadea6410cc13cbe059202655980ac\",\"version\":\"v6.1.2\"},{\"arch\":\"amd64\",\"name\":\"buildozer\",\"platform\":\"windows\",\"sha256\":\"07664d5d08ee099f069cd654070cabf2708efaae9f52dc83921fa400c67a868b\",\"version\":\"v6.1.2\"}]" - } - } - }, - "recordedRepoMappingEntries": [ - [ - "buildifier_prebuilt+", - "bazel_skylib", - "bazel_skylib+" - ], - [ - "buildifier_prebuilt+", - "bazel_tools", - "bazel_tools" - ] - ] - } - }, - "@@platforms//host:extension.bzl%host_platform": { - "general": { - "bzlTransitiveDigest": "xelQcPZH8+tmuOHVjL9vDxMnnQNMlwj0SlvgoqBkm4U=", - "usagesDigest": "SeQiIN/f8/Qt9vYQk7qcXp4I4wJeEC0RnQDiaaJ4tb8=", - "recordedFileInputs": {}, - "recordedDirentsInputs": {}, - "envVariables": {}, - "generatedRepoSpecs": { - "host_platform": { - "repoRuleId": "@@platforms//host:extension.bzl%host_platform_repo", - "attributes": {} - } - }, - "recordedRepoMappingEntries": [] - } - }, - "@@rules_java+//java:rules_java_deps.bzl%compatibility_proxy": { - "general": { - "bzlTransitiveDigest": "84xJEZ1jnXXwo8BXMprvBm++rRt4jsTu9liBxz0ivps=", - "usagesDigest": "jTQDdLDxsS43zuRmg1faAjIEPWdLAbDAowI1pInQSoo=", - "recordedFileInputs": {}, - "recordedDirentsInputs": {}, - "envVariables": {}, - "generatedRepoSpecs": { - "compatibility_proxy": { - "repoRuleId": "@@rules_java+//java:rules_java_deps.bzl%_compatibility_proxy_repo_rule", - "attributes": {} - } - }, - "recordedRepoMappingEntries": [ - [ - "rules_java+", - "bazel_tools", - "bazel_tools" - ] - ] - } - }, - "@@rules_kotlin+//src/main/starlark/core/repositories:bzlmod_setup.bzl%rules_kotlin_extensions": { - "general": { - "bzlTransitiveDigest": "sFhcgPbDQehmbD1EOXzX4H1q/CD5df8zwG4kp4jbvr8=", - "usagesDigest": "QI2z8ZUR+mqtbwsf2fLqYdJAkPOHdOV+tF2yVAUgRzw=", - "recordedFileInputs": {}, - "recordedDirentsInputs": {}, - "envVariables": {}, - "generatedRepoSpecs": { - "com_github_jetbrains_kotlin_git": { - "repoRuleId": "@@rules_kotlin+//src/main/starlark/core/repositories:compiler.bzl%kotlin_compiler_git_repository", - "attributes": { - "urls": [ - "https://github.com/JetBrains/kotlin/releases/download/v1.9.23/kotlin-compiler-1.9.23.zip" - ], - "sha256": "93137d3aab9afa9b27cb06a824c2324195c6b6f6179d8a8653f440f5bd58be88" - } - }, - "com_github_jetbrains_kotlin": { - "repoRuleId": "@@rules_kotlin+//src/main/starlark/core/repositories:compiler.bzl%kotlin_capabilities_repository", - "attributes": { - "git_repository_name": "com_github_jetbrains_kotlin_git", - "compiler_version": "1.9.23" - } - }, - "com_github_google_ksp": { - "repoRuleId": "@@rules_kotlin+//src/main/starlark/core/repositories:ksp.bzl%ksp_compiler_plugin_repository", - "attributes": { - "urls": [ - "https://github.com/google/ksp/releases/download/1.9.23-1.0.20/artifacts.zip" - ], - "sha256": "ee0618755913ef7fd6511288a232e8fad24838b9af6ea73972a76e81053c8c2d", - "strip_version": "1.9.23-1.0.20" - } - }, - "com_github_pinterest_ktlint": { - "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file", - "attributes": { - "sha256": "01b2e0ef893383a50dbeb13970fe7fa3be36ca3e83259e01649945b09d736985", - "urls": [ - "https://github.com/pinterest/ktlint/releases/download/1.3.0/ktlint" - ], - "executable": true - } - }, - "rules_android": { - "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", - "attributes": { - "sha256": "cd06d15dd8bb59926e4d65f9003bfc20f9da4b2519985c27e190cddc8b7a7806", - "strip_prefix": "rules_android-0.1.1", - "urls": [ - "https://github.com/bazelbuild/rules_android/archive/v0.1.1.zip" - ] - } - } - }, - "recordedRepoMappingEntries": [ - [ - "rules_kotlin+", - "bazel_tools", - "bazel_tools" - ] - ] - } - } - } -} From c5ff77a7cf7b9f36cb12f5f84997f6be3b3e1197 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Mon, 24 Feb 2025 01:17:59 +0900 Subject: [PATCH 41/65] simplify --- python/private/pypi/extension.bzl | 19 ++++--------------- python/private/pypi/pip_repository.bzl | 4 +--- 2 files changed, 5 insertions(+), 18 deletions(-) diff --git a/python/private/pypi/extension.bzl b/python/private/pypi/extension.bzl index 92d1d50937..bc89bb44ad 100644 --- a/python/private/pypi/extension.bzl +++ b/python/private/pypi/extension.bzl @@ -166,21 +166,10 @@ def _create_whl_repos( ), extra_pip_args = pip_attr.extra_pip_args, get_index_urls = get_index_urls, - # NOTE @aignas 2024-08-02: , we will execute any interpreter that we find either - # in the PATH or if specified as a label. We will configure the env - # markers when evaluating the requirement lines based on the output - # from the `requirements_files_by_platform` which should have something - # similar to: - # { - # "//:requirements.txt": ["cp311_linux_x86_64", ...] - # } - # - # We know the target python versions that we need to evaluate the - # markers for and thus we don't need to use multiple python interpreter - # instances to perform this manipulation. This function should be executed - # only once by the underlying code to minimize the overhead needed to - # spin up a Python interpreter. - evaluate_markers = lambda r: evaluate_markers(r), + # NOTE @aignas 2025-02-24: we will use the "cp3xx_os_arch" platform labels + # for converting to the PEP508 environment and will evaluate them in starlark + # without involving the interpreter at all. + evaluate_markers = evaluate_markers, logger = logger, ) diff --git a/python/private/pypi/pip_repository.bzl b/python/private/pypi/pip_repository.bzl index 7f0ea9827a..88b1e631e7 100644 --- a/python/private/pypi/pip_repository.bzl +++ b/python/private/pypi/pip_repository.bzl @@ -82,9 +82,7 @@ def _pip_repository_impl(rctx): extra_pip_args = rctx.attr.extra_pip_args, ), extra_pip_args = rctx.attr.extra_pip_args, - evaluate_markers = lambda requirements: evaluate_markers( - requirements = requirements, - ), + evaluate_markers = evaluate_markers, ) selected_requirements = {} options = None From b92a67d36c30520f614636b9484318db05d401b6 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Mon, 24 Feb 2025 01:20:56 +0900 Subject: [PATCH 42/65] wip --- python/private/pypi/whl_library.bzl | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/python/private/pypi/whl_library.bzl b/python/private/pypi/whl_library.bzl index b8e58b3a84..1f0514069c 100644 --- a/python/private/pypi/whl_library.bzl +++ b/python/private/pypi/whl_library.bzl @@ -335,12 +335,16 @@ def _whl_library_impl(rctx): ) entry_points[entry_point_without_py] = entry_point_script_name + # TODO @aignas 2025-02-24: move this to pkg_aliases layer to have this in + # the analysis phase. This means that we need to get the target platform abi + # from the python version/versions we are setting the package up for. We can + # potentially get this from the python toolchain interpreter. package_deps = deps( + # TODO @aignas 2025-02-24: get the data here by parsing the METADATA + # file manually without involving python interpreter at all. name = metadata["name"], requires_dist = metadata["requires_dist"], # target the host platform if the target platform is not specified in the rule. - # TODO @aignas 2025-02-24: move this to pkg_aliases layer to have this in the - # analysis phase. platforms = target_platforms or [ "{}_{}".format(metadata["abi"], host_platform(rctx)), ], From 6177760b27e1433e535435a17717fa544468f88d Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Mar 2025 16:48:54 +0900 Subject: [PATCH 43/65] add notes --- python/private/pypi/whl_library.bzl | 18 ++++++++++++++++++ python/private/pypi/whl_library_targets.bzl | 2 -- 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/python/private/pypi/whl_library.bzl b/python/private/pypi/whl_library.bzl index 6e16c5cd27..72d6821939 100644 --- a/python/private/pypi/whl_library.bzl +++ b/python/private/pypi/whl_library.bzl @@ -364,25 +364,43 @@ def _whl_library_impl(rctx): name = metadata["name"], requires_dist = metadata["requires_dist"], # target the host platform if the target platform is not specified in the rule. + # TODO @aignas 2025-03-23: we should materialize this inside the + # hub_repository `requirements.bzl` file as `TARGET_PLATFORMS` with a + # note, that this is internal and will be only for usage of the + # `whl_library` platforms = target_platforms or [ "{}_{}".format(metadata["abi"], host_platform(rctx)), ], + # TODO @aignas 2025-03-23: we should expose the requested extras via a + # dict in `requirements.bzl` `EXTRAS` where the key is the package name + # and the value is the list of requested extras. like the above, for + # internal usage only. extras = metadata["extras"], + # TODO @aignas 2025-03-23: we should expose full python version via the + # TARGET_PYTHON_VERSIONS list so that we can correctly calculate the + # deps. This would be again, internal only stuff. + host_python_version = metadata["python_version"], ) build_file_contents = generate_whl_library_build_bazel( name = whl_path.basename, + # TODO @aignas 2025-03-23: load the dep_template from the hub repository dep_template = rctx.attr.dep_template or "@{}{{name}}//:{{target}}".format(rctx.attr.repo_prefix), + # TODO @aignas 2025-03-23: replace `dependencies` and + # `dependencies_by_platform` with `requires_dist`. dependencies = package_deps.deps, dependencies_by_platform = package_deps.deps_select, + # TODO @aignas 2025-03-23: store the `group_name` per package in the hub repo group_name = rctx.attr.group_name, group_deps = rctx.attr.group_deps, + # TODO @aignas 2025-03-23: store the pip_data_exclude in the hub repo. data_exclude = rctx.attr.pip_data_exclude, tags = [ "pypi_name=" + metadata["name"], "pypi_version=" + metadata["version"], ], entry_points = entry_points, + # TODO @aignas 2025-03-23: store the annotation in the hub repo. annotation = None if not rctx.attr.annotation else struct(**json.decode(rctx.read(rctx.attr.annotation))), ) rctx.file("BUILD.bazel", build_file_contents) diff --git a/python/private/pypi/whl_library_targets.bzl b/python/private/pypi/whl_library_targets.bzl index c390da2613..38ed57d0d2 100644 --- a/python/private/pypi/whl_library_targets.bzl +++ b/python/private/pypi/whl_library_targets.bzl @@ -90,8 +90,6 @@ def whl_library_targets( native: {type}`native` The native struct for overriding in tests. rules: {type}`struct` A struct with references to rules for creating targets. """ - _ = name # buildifier: @unused - dependencies = sorted([normalize_name(d) for d in dependencies]) dependencies_by_platform = { platform: sorted([normalize_name(d) for d in deps]) From 96f65e03df8b2e2ae6dbad8499dc95b36d2cb87c Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Mar 2025 16:58:02 +0900 Subject: [PATCH 44/65] pass the version --- python/private/pypi/whl_installer/wheel_installer.py | 1 + 1 file changed, 1 insertion(+) diff --git a/python/private/pypi/whl_installer/wheel_installer.py b/python/private/pypi/whl_installer/wheel_installer.py index 802f280287..3ccd9bad60 100644 --- a/python/private/pypi/whl_installer/wheel_installer.py +++ b/python/private/pypi/whl_installer/wheel_installer.py @@ -129,6 +129,7 @@ def _extract_wheel( "name": whl.name, "version": whl.version, "extras": list(extras_requested), + "python_version": sys.version.partition(" ")[0], "requires_dist": requires_dist, "abi": abi, "entry_points": [ From 7f99cb76977023cc36592a459f647c927fac5d46 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Mar 2025 17:05:25 +0900 Subject: [PATCH 45/65] move the dep parsing to the analysis phase --- .../pypi/generate_whl_library_build_bazel.bzl | 3 ++ python/private/pypi/whl_library.bzl | 46 +++++++------------ python/private/pypi/whl_library_targets.bzl | 36 ++++++++++++--- 3 files changed, 48 insertions(+), 37 deletions(-) diff --git a/python/private/pypi/generate_whl_library_build_bazel.bzl b/python/private/pypi/generate_whl_library_build_bazel.bzl index 8050cd22ad..977b4d2377 100644 --- a/python/private/pypi/generate_whl_library_build_bazel.bzl +++ b/python/private/pypi/generate_whl_library_build_bazel.bzl @@ -24,7 +24,10 @@ _RENDER = { "dependencies": render.list, "dependencies_by_platform": lambda x: render.dict(x, value_repr = render.list), "entry_points": render.dict, + "extras": render.list, "group_deps": render.list, + "platforms": render.list, + "requires_dist": render.list, "srcs_exclude": render.list, "tags": render.list, } diff --git a/python/private/pypi/whl_library.bzl b/python/private/pypi/whl_library.bzl index 72d6821939..b6dbc3c2ae 100644 --- a/python/private/pypi/whl_library.bzl +++ b/python/private/pypi/whl_library.bzl @@ -24,7 +24,6 @@ load(":generate_whl_library_build_bazel.bzl", "generate_whl_library_build_bazel" load(":parse_requirements.bzl", "host_platform") load(":parse_whl_name.bzl", "parse_whl_name") load(":patch_whl.bzl", "patch_whl") -load(":pep508_env.bzl", "deps") load(":pypi_repo_utils.bzl", "pypi_repo_utils") load(":whl_target_platforms.bzl", "whl_target_platforms") @@ -354,13 +353,22 @@ def _whl_library_impl(rctx): ) entry_points[entry_point_without_py] = entry_point_script_name - # TODO @aignas 2025-02-24: move this to pkg_aliases layer to have this in - # the analysis phase. This means that we need to get the target platform abi - # from the python version/versions we are setting the package up for. We can - # potentially get this from the python toolchain interpreter. - package_deps = deps( - # TODO @aignas 2025-02-24: get the data here by parsing the METADATA - # file manually without involving python interpreter at all. + build_file_contents = generate_whl_library_build_bazel( + whl_name = whl_path.basename, + # TODO @aignas 2025-03-23: load the dep_template from the hub repository + dep_template = rctx.attr.dep_template or "@{}{{name}}//:{{target}}".format(rctx.attr.repo_prefix), + # TODO @aignas 2025-03-23: store the `group_name` per package in the hub repo + group_name = rctx.attr.group_name, + group_deps = rctx.attr.group_deps, + # TODO @aignas 2025-03-23: store the pip_data_exclude in the hub repo. + data_exclude = rctx.attr.pip_data_exclude, + tags = [ + "pypi_name=" + metadata["name"], + "pypi_version=" + metadata["version"], + ], + entry_points = entry_points, + # TODO @aignas 2025-03-23: store the annotation in the hub repo. + annotation = None if not rctx.attr.annotation else struct(**json.decode(rctx.read(rctx.attr.annotation))), name = metadata["name"], requires_dist = metadata["requires_dist"], # target the host platform if the target platform is not specified in the rule. @@ -381,28 +389,6 @@ def _whl_library_impl(rctx): # deps. This would be again, internal only stuff. host_python_version = metadata["python_version"], ) - - build_file_contents = generate_whl_library_build_bazel( - name = whl_path.basename, - # TODO @aignas 2025-03-23: load the dep_template from the hub repository - dep_template = rctx.attr.dep_template or "@{}{{name}}//:{{target}}".format(rctx.attr.repo_prefix), - # TODO @aignas 2025-03-23: replace `dependencies` and - # `dependencies_by_platform` with `requires_dist`. - dependencies = package_deps.deps, - dependencies_by_platform = package_deps.deps_select, - # TODO @aignas 2025-03-23: store the `group_name` per package in the hub repo - group_name = rctx.attr.group_name, - group_deps = rctx.attr.group_deps, - # TODO @aignas 2025-03-23: store the pip_data_exclude in the hub repo. - data_exclude = rctx.attr.pip_data_exclude, - tags = [ - "pypi_name=" + metadata["name"], - "pypi_version=" + metadata["version"], - ], - entry_points = entry_points, - # TODO @aignas 2025-03-23: store the annotation in the hub repo. - annotation = None if not rctx.attr.annotation else struct(**json.decode(rctx.read(rctx.attr.annotation))), - ) rctx.file("BUILD.bazel", build_file_contents) return diff --git a/python/private/pypi/whl_library_targets.bzl b/python/private/pypi/whl_library_targets.bzl index 38ed57d0d2..3102f354a0 100644 --- a/python/private/pypi/whl_library_targets.bzl +++ b/python/private/pypi/whl_library_targets.bzl @@ -29,10 +29,12 @@ load( "WHEEL_FILE_IMPL_LABEL", "WHEEL_FILE_PUBLIC_LABEL", ) +load(":pep508_env.bzl", "deps") def whl_library_targets( *, name, + whl_name, dep_template, data_exclude = [], srcs_exclude = [], @@ -41,14 +43,16 @@ def whl_library_targets( DIST_INFO_LABEL: ["site-packages/*.dist-info/**"], DATA_LABEL: ["data/**"], }, - dependencies = [], - dependencies_by_platform = {}, group_deps = [], group_name = "", data = [], copy_files = {}, copy_executables = {}, entry_points = {}, + requires_dist = [], + platforms, + extras = [], + host_python_version, native = native, rules = struct( copy_file = copy_file, @@ -58,14 +62,12 @@ def whl_library_targets( """Create all of the whl_library targets. Args: - name: {type}`str` The file to match for including it into the `whl` + name: {type}`str` the name of the distribution. + whl_name: {type}`str` The file to match for including it into the `whl` filegroup. This may be also parsed to generate extra metadata. dep_template: {type}`str` The dep_template to use for dependency interpolation. tags: {type}`list[str]` The tags set on the `py_library`. - dependencies: {type}`list[str]` A list of dependencies. - dependencies_by_platform: {type}`dict[str, list[str]]` A list of - dependencies by platform key. filegroups: {type}`dict[str, list[str]]` A dictionary of the target names and the glob matches. group_name: {type}`str` name of the dependency group (if any) which @@ -87,9 +89,29 @@ def whl_library_targets( data: {type}`list[str]` A list of labels to include as part of the `data` attribute in `py_library`. entry_points: {type}`dict[str, str]` The mapping between the script name and the python file to use. DEPRECATED. + requires_dist: TODO + platforms: TODO + extras: TODO + host_python_version: TODO native: {type}`native` The native struct for overriding in tests. rules: {type}`struct` A struct with references to rules for creating targets. """ + + # TODO @aignas 2025-02-24: move this to pkg_aliases layer to have this in + # the analysis phase. This means that we need to get the target platform abi + # from the python version/versions we are setting the package up for. We can + # potentially get this from the python toolchain interpreter. + package_deps = deps( + name = name, + requires_dist = requires_dist, + platforms = platforms, + extras = extras, + host_python_version = host_python_version, + ) + + dependencies = package_deps.deps + dependencies_by_platform = package_deps.deps_select + dependencies = sorted([normalize_name(d) for d in dependencies]) dependencies_by_platform = { platform: sorted([normalize_name(d) for d in deps]) @@ -203,7 +225,7 @@ def whl_library_targets( if hasattr(native, "filegroup"): native.filegroup( name = whl_file_label, - srcs = [name], + srcs = [whl_name], data = _deps( deps = dependencies, deps_by_platform = dependencies_by_platform, From 1de82690a5eaa9d05b9ef887938093b8c3c376f1 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 23 Mar 2025 18:04:57 +0900 Subject: [PATCH 46/65] wip --- python/private/pypi/extension.bzl | 23 ++++++++++++++++ .../pypi/generate_whl_library_build_bazel.bzl | 24 +++++++++++++++-- python/private/pypi/hub_repository.bzl | 26 +++++++++++++++++++ .../private/pypi/requirements.bzl.tmpl.bzlmod | 9 +++++++ python/private/pypi/whl_library.bzl | 23 ++++------------ python/private/pypi/whl_library_targets.bzl | 8 ++---- 6 files changed, 87 insertions(+), 26 deletions(-) diff --git a/python/private/pypi/extension.bzl b/python/private/pypi/extension.bzl index 8353d2359c..a5f97bc4da 100644 --- a/python/private/pypi/extension.bzl +++ b/python/private/pypi/extension.bzl @@ -16,7 +16,9 @@ load("@bazel_features//:features.bzl", "bazel_features") load("@pythons_hub//:interpreters.bzl", "INTERPRETER_LABELS") +load("@pythons_hub//:versions.bzl", "MINOR_MAPPING") load("//python/private:auth.bzl", "AUTH_ATTRS") +load("//python/private:full_version.bzl", "full_version") load("//python/private:normalize_name.bzl", "normalize_name") load("//python/private:repo_utils.bzl", "repo_utils") load("//python/private:semver.bzl", "semver") @@ -173,6 +175,7 @@ def _create_whl_repos( logger = logger, ) + platforms = {} for whl_name, requirements in requirements_by_platform.items(): group_name = whl_group_mapping.get(whl_name) group_deps = requirement_cycles.get(group_name, []) @@ -233,6 +236,10 @@ def _create_whl_repos( )) whl_libraries[repo_name] = args + + # TODO @aignas 2025-03-23: make this more efficient + for p in args.pop("experimental_target_platforms", []): + platforms[p] = None whl_map.setdefault(whl_name, {})[config_setting] = repo_name return struct( @@ -244,6 +251,7 @@ def _create_whl_repos( }, extra_aliases = extra_aliases, whl_libraries = whl_libraries, + platforms = platforms, ) def _whl_repos(*, requirement, whl_library_args, download_only, netrc, auth_patterns, multiple_requirements_for_whl = False, python_version): @@ -408,6 +416,7 @@ You cannot use both the additive_build_content and additive_build_content_file a exposed_packages = {} extra_aliases = {} whl_libraries = {} + platforms = {} is_reproducible = True @@ -485,6 +494,7 @@ You cannot use both the additive_build_content and additive_build_content_file a extra_aliases[hub_name].setdefault(whl_name, {}).update(aliases) exposed_packages.setdefault(hub_name, {}).update(out.exposed_packages) whl_libraries.update(out.whl_libraries) + platforms.setdefault(hub_name, {}).update(out.platforms) # TODO @aignas 2024-04-05: how do we support different requirement # cycles for different abis/oses? For now we will need the users to @@ -521,6 +531,17 @@ You cannot use both the additive_build_content and additive_build_content_file a } for hub_name, extra_whl_aliases in extra_aliases.items() }, + platforms = { + hub_name: sorted(p) + for hub_name, p in platforms.items() + }, + python_versions = { + hub_name: sorted({ + full_version(version = v, minor_mapping = MINOR_MAPPING): None + for v in m.python_versions + }) + for hub_name, m in pip_hub_map.items() + }, whl_libraries = { k: dict(sorted(args.items())) for k, args in sorted(whl_libraries.items()) @@ -612,6 +633,8 @@ def _pip_impl(module_ctx): for key, values in whl_map.items() }, packages = mods.exposed_packages.get(hub_name, []), + python_versions = mods.python_versions[hub_name], + platforms = mods.platforms.get(hub_name, ["host"]), groups = mods.hub_group_map.get(hub_name), ) diff --git a/python/private/pypi/generate_whl_library_build_bazel.bzl b/python/private/pypi/generate_whl_library_build_bazel.bzl index 977b4d2377..0047a33c6a 100644 --- a/python/private/pypi/generate_whl_library_build_bazel.bzl +++ b/python/private/pypi/generate_whl_library_build_bazel.bzl @@ -14,6 +14,7 @@ """Generate the BUILD.bazel contents for a repo defined by a whl_library.""" +load("//python/private:bzlmod_enabled.bzl", "BZLMOD_ENABLED") load("//python/private:text_util.bzl", "render") _RENDER = { @@ -26,7 +27,8 @@ _RENDER = { "entry_points": render.dict, "extras": render.list, "group_deps": render.list, - "platforms": render.list, + "host_python_version": str, + "platforms": str, "requires_dist": render.list, "srcs_exclude": render.list, "tags": render.list, @@ -36,7 +38,7 @@ _RENDER = { # this repository can be publicly visible without the need for # export_files _TEMPLATE = """\ -load("@rules_python//python/private/pypi:whl_library_targets.bzl", "whl_library_targets") +{loads} package(default_visibility = ["//visibility:public"]) @@ -61,6 +63,17 @@ def generate_whl_library_build_bazel( """ additional_content = [] + loads = { + "@rules_python//python/private/pypi:whl_library_targets.bzl": ('"whl_library_targets"',), + } + if BZLMOD_ENABLED: + dep_template = kwargs["dep_template"] + loads[dep_template.format( + name = "", + target = "requirements.bzl", + )] = ("hub_settings = \"private\"",) + kwargs["platforms"] = "hub_settings.platforms" + kwargs["host_python_version"] = "hub_settings.python_versions[0]" if annotation: kwargs["data"] = annotation.data kwargs["copy_files"] = annotation.copy_files @@ -73,6 +86,13 @@ def generate_whl_library_build_bazel( contents = "\n".join( [ _TEMPLATE.format( + loads = "\n".join([ + "load({}, {})".format( + repr(path), + ", ".join([s for s in symbols]), + ) + for path, symbols in loads.items() + ]), kwargs = render.indent("\n".join([ "{} = {},".format(k, _RENDER.get(k, repr)(v)) for k, v in sorted(kwargs.items()) diff --git a/python/private/pypi/hub_repository.bzl b/python/private/pypi/hub_repository.bzl index 48245b4106..82ef0f3246 100644 --- a/python/private/pypi/hub_repository.bzl +++ b/python/private/pypi/hub_repository.bzl @@ -15,6 +15,7 @@ "" load("//python/private:text_util.bzl", "render") +load(":parse_requirements.bzl", "host_platform") load(":render_pkg_aliases.bzl", "render_multiplatform_pkg_aliases") load(":whl_config_setting.bzl", "whl_config_setting") @@ -44,6 +45,11 @@ def _impl(rctx): # `requirement`, et al. macros. macro_tmpl = "@@{name}//{{}}:{{}}".format(name = rctx.attr.name) + platforms = [ + host_platform(rctx) if p == "host" else p + for p in rctx.attr.platforms + ] + rctx.file("BUILD.bazel", _BUILD_FILE_CONTENTS) rctx.template("requirements.bzl", rctx.attr._template, substitutions = { "%%ALL_DATA_REQUIREMENTS%%": render.list([ @@ -59,6 +65,8 @@ def _impl(rctx): for p in bzl_packages }), "%%MACRO_TMPL%%": macro_tmpl, + "%%PLATFORMS%%": render.indent(render.list(sorted(platforms))).lstrip(), + "%%PYTHON_VERSIONS%%": render.indent(render.list(sorted(rctx.attr.python_versions))).lstrip(), }) hub_repository = repository_rule( @@ -74,6 +82,24 @@ hub_repository = repository_rule( mandatory = False, doc = """\ The list of packages that will be exposed via all_*requirements macros. Defaults to whl_map keys. +""", + ), + # TODO @aignas 2025-03-23: get the `platforms` and `python_versions` + # from the aliases? This requires us to only create aliases for the + # target platforms and python_versions we care about. Python versions + # probably still need to be passed in. + "platforms": attr.string_list( + mandatory = True, + doc = """\ +The list of target platforms that are supported in this hub repository. This +can contain 'abi_os_arch' tuples or 'host' to keep the lock files os/arch +agnostic. +""", + ), + "python_versions": attr.string_list( + mandatory = True, + doc = """\ +The list of python versions that are supported in this hub repository. """, ), "repo_name": attr.string( diff --git a/python/private/pypi/requirements.bzl.tmpl.bzlmod b/python/private/pypi/requirements.bzl.tmpl.bzlmod index ba227aeb2d..3b1f7d4a11 100644 --- a/python/private/pypi/requirements.bzl.tmpl.bzlmod +++ b/python/private/pypi/requirements.bzl.tmpl.bzlmod @@ -13,6 +13,15 @@ all_whl_requirements = all_whl_requirements_by_package.values() all_data_requirements = %%ALL_DATA_REQUIREMENTS%% +# Internal constants used for passing information to `whl_library` +# repositories without causing re-fetching. This is not intended to be +# a stable API and may break. If you would like to depend on it, please raise +# a ticket describing your use-case. +private = struct( + python_versions = %%PYTHON_VERSIONS%%, + platforms = %%PLATFORMS%%, +) + def requirement(name): return "%%MACRO_TMPL%%".format(pip_utils.normalize_name(name), "pkg") diff --git a/python/private/pypi/whl_library.bzl b/python/private/pypi/whl_library.bzl index b6dbc3c2ae..b0ca532d3c 100644 --- a/python/private/pypi/whl_library.bzl +++ b/python/private/pypi/whl_library.bzl @@ -21,7 +21,6 @@ load("//python/private:repo_utils.bzl", "REPO_DEBUG_ENV_VAR", "repo_utils") load(":attrs.bzl", "ATTRS", "use_isolated") load(":deps.bzl", "all_repo_names", "record_files") load(":generate_whl_library_build_bazel.bzl", "generate_whl_library_build_bazel") -load(":parse_requirements.bzl", "host_platform") load(":parse_whl_name.bzl", "parse_whl_name") load(":patch_whl.bzl", "patch_whl") load(":pypi_repo_utils.bzl", "pypi_repo_utils") @@ -354,6 +353,7 @@ def _whl_library_impl(rctx): entry_points[entry_point_without_py] = entry_point_script_name build_file_contents = generate_whl_library_build_bazel( + name = metadata["name"], whl_name = whl_path.basename, # TODO @aignas 2025-03-23: load the dep_template from the hub repository dep_template = rctx.attr.dep_template or "@{}{{name}}//:{{target}}".format(rctx.attr.repo_prefix), @@ -369,25 +369,12 @@ def _whl_library_impl(rctx): entry_points = entry_points, # TODO @aignas 2025-03-23: store the annotation in the hub repo. annotation = None if not rctx.attr.annotation else struct(**json.decode(rctx.read(rctx.attr.annotation))), - name = metadata["name"], requires_dist = metadata["requires_dist"], - # target the host platform if the target platform is not specified in the rule. - # TODO @aignas 2025-03-23: we should materialize this inside the - # hub_repository `requirements.bzl` file as `TARGET_PLATFORMS` with a - # note, that this is internal and will be only for usage of the - # `whl_library` - platforms = target_platforms or [ - "{}_{}".format(metadata["abi"], host_platform(rctx)), - ], - # TODO @aignas 2025-03-23: we should expose the requested extras via a - # dict in `requirements.bzl` `EXTRAS` where the key is the package name - # and the value is the list of requested extras. like the above, for - # internal usage only. + # TODO @aignas 2025-03-23: we should just generate targets for all of the + # exposed extras and ask users to depend on this by `@pypi//foo:foo__extra`. + # Since all of the dependencies go through the `hub` repository, the extras + # that include packages that we don't extras = metadata["extras"], - # TODO @aignas 2025-03-23: we should expose full python version via the - # TARGET_PYTHON_VERSIONS list so that we can correctly calculate the - # deps. This would be again, internal only stuff. - host_python_version = metadata["python_version"], ) rctx.file("BUILD.bazel", build_file_contents) diff --git a/python/private/pypi/whl_library_targets.bzl b/python/private/pypi/whl_library_targets.bzl index 3102f354a0..169918eb16 100644 --- a/python/private/pypi/whl_library_targets.bzl +++ b/python/private/pypi/whl_library_targets.bzl @@ -58,6 +58,7 @@ def whl_library_targets( copy_file = copy_file, py_binary = py_binary, py_library = py_library, + deps = deps, )): """Create all of the whl_library targets. @@ -101,7 +102,7 @@ def whl_library_targets( # the analysis phase. This means that we need to get the target platform abi # from the python version/versions we are setting the package up for. We can # potentially get this from the python toolchain interpreter. - package_deps = deps( + package_deps = rules.deps( name = name, requires_dist = requires_dist, platforms = platforms, @@ -112,11 +113,6 @@ def whl_library_targets( dependencies = package_deps.deps dependencies_by_platform = package_deps.deps_select - dependencies = sorted([normalize_name(d) for d in dependencies]) - dependencies_by_platform = { - platform: sorted([normalize_name(d) for d in deps]) - for platform, deps in dependencies_by_platform.items() - } tags = sorted(tags) data = [] + data From 9f405366018f9c176034ca83470f96b226f9b4b3 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Fri, 4 Apr 2025 09:34:40 +0900 Subject: [PATCH 47/65] Revert "wip" This reverts commit 1de82690a5eaa9d05b9ef887938093b8c3c376f1. --- python/private/pypi/extension.bzl | 23 ---------------- .../pypi/generate_whl_library_build_bazel.bzl | 24 ++--------------- python/private/pypi/hub_repository.bzl | 26 ------------------- .../private/pypi/requirements.bzl.tmpl.bzlmod | 9 ------- python/private/pypi/whl_library.bzl | 23 ++++++++++++---- python/private/pypi/whl_library_targets.bzl | 8 ++++-- 6 files changed, 26 insertions(+), 87 deletions(-) diff --git a/python/private/pypi/extension.bzl b/python/private/pypi/extension.bzl index a5f97bc4da..8353d2359c 100644 --- a/python/private/pypi/extension.bzl +++ b/python/private/pypi/extension.bzl @@ -16,9 +16,7 @@ load("@bazel_features//:features.bzl", "bazel_features") load("@pythons_hub//:interpreters.bzl", "INTERPRETER_LABELS") -load("@pythons_hub//:versions.bzl", "MINOR_MAPPING") load("//python/private:auth.bzl", "AUTH_ATTRS") -load("//python/private:full_version.bzl", "full_version") load("//python/private:normalize_name.bzl", "normalize_name") load("//python/private:repo_utils.bzl", "repo_utils") load("//python/private:semver.bzl", "semver") @@ -175,7 +173,6 @@ def _create_whl_repos( logger = logger, ) - platforms = {} for whl_name, requirements in requirements_by_platform.items(): group_name = whl_group_mapping.get(whl_name) group_deps = requirement_cycles.get(group_name, []) @@ -236,10 +233,6 @@ def _create_whl_repos( )) whl_libraries[repo_name] = args - - # TODO @aignas 2025-03-23: make this more efficient - for p in args.pop("experimental_target_platforms", []): - platforms[p] = None whl_map.setdefault(whl_name, {})[config_setting] = repo_name return struct( @@ -251,7 +244,6 @@ def _create_whl_repos( }, extra_aliases = extra_aliases, whl_libraries = whl_libraries, - platforms = platforms, ) def _whl_repos(*, requirement, whl_library_args, download_only, netrc, auth_patterns, multiple_requirements_for_whl = False, python_version): @@ -416,7 +408,6 @@ You cannot use both the additive_build_content and additive_build_content_file a exposed_packages = {} extra_aliases = {} whl_libraries = {} - platforms = {} is_reproducible = True @@ -494,7 +485,6 @@ You cannot use both the additive_build_content and additive_build_content_file a extra_aliases[hub_name].setdefault(whl_name, {}).update(aliases) exposed_packages.setdefault(hub_name, {}).update(out.exposed_packages) whl_libraries.update(out.whl_libraries) - platforms.setdefault(hub_name, {}).update(out.platforms) # TODO @aignas 2024-04-05: how do we support different requirement # cycles for different abis/oses? For now we will need the users to @@ -531,17 +521,6 @@ You cannot use both the additive_build_content and additive_build_content_file a } for hub_name, extra_whl_aliases in extra_aliases.items() }, - platforms = { - hub_name: sorted(p) - for hub_name, p in platforms.items() - }, - python_versions = { - hub_name: sorted({ - full_version(version = v, minor_mapping = MINOR_MAPPING): None - for v in m.python_versions - }) - for hub_name, m in pip_hub_map.items() - }, whl_libraries = { k: dict(sorted(args.items())) for k, args in sorted(whl_libraries.items()) @@ -633,8 +612,6 @@ def _pip_impl(module_ctx): for key, values in whl_map.items() }, packages = mods.exposed_packages.get(hub_name, []), - python_versions = mods.python_versions[hub_name], - platforms = mods.platforms.get(hub_name, ["host"]), groups = mods.hub_group_map.get(hub_name), ) diff --git a/python/private/pypi/generate_whl_library_build_bazel.bzl b/python/private/pypi/generate_whl_library_build_bazel.bzl index 0047a33c6a..977b4d2377 100644 --- a/python/private/pypi/generate_whl_library_build_bazel.bzl +++ b/python/private/pypi/generate_whl_library_build_bazel.bzl @@ -14,7 +14,6 @@ """Generate the BUILD.bazel contents for a repo defined by a whl_library.""" -load("//python/private:bzlmod_enabled.bzl", "BZLMOD_ENABLED") load("//python/private:text_util.bzl", "render") _RENDER = { @@ -27,8 +26,7 @@ _RENDER = { "entry_points": render.dict, "extras": render.list, "group_deps": render.list, - "host_python_version": str, - "platforms": str, + "platforms": render.list, "requires_dist": render.list, "srcs_exclude": render.list, "tags": render.list, @@ -38,7 +36,7 @@ _RENDER = { # this repository can be publicly visible without the need for # export_files _TEMPLATE = """\ -{loads} +load("@rules_python//python/private/pypi:whl_library_targets.bzl", "whl_library_targets") package(default_visibility = ["//visibility:public"]) @@ -63,17 +61,6 @@ def generate_whl_library_build_bazel( """ additional_content = [] - loads = { - "@rules_python//python/private/pypi:whl_library_targets.bzl": ('"whl_library_targets"',), - } - if BZLMOD_ENABLED: - dep_template = kwargs["dep_template"] - loads[dep_template.format( - name = "", - target = "requirements.bzl", - )] = ("hub_settings = \"private\"",) - kwargs["platforms"] = "hub_settings.platforms" - kwargs["host_python_version"] = "hub_settings.python_versions[0]" if annotation: kwargs["data"] = annotation.data kwargs["copy_files"] = annotation.copy_files @@ -86,13 +73,6 @@ def generate_whl_library_build_bazel( contents = "\n".join( [ _TEMPLATE.format( - loads = "\n".join([ - "load({}, {})".format( - repr(path), - ", ".join([s for s in symbols]), - ) - for path, symbols in loads.items() - ]), kwargs = render.indent("\n".join([ "{} = {},".format(k, _RENDER.get(k, repr)(v)) for k, v in sorted(kwargs.items()) diff --git a/python/private/pypi/hub_repository.bzl b/python/private/pypi/hub_repository.bzl index 82ef0f3246..48245b4106 100644 --- a/python/private/pypi/hub_repository.bzl +++ b/python/private/pypi/hub_repository.bzl @@ -15,7 +15,6 @@ "" load("//python/private:text_util.bzl", "render") -load(":parse_requirements.bzl", "host_platform") load(":render_pkg_aliases.bzl", "render_multiplatform_pkg_aliases") load(":whl_config_setting.bzl", "whl_config_setting") @@ -45,11 +44,6 @@ def _impl(rctx): # `requirement`, et al. macros. macro_tmpl = "@@{name}//{{}}:{{}}".format(name = rctx.attr.name) - platforms = [ - host_platform(rctx) if p == "host" else p - for p in rctx.attr.platforms - ] - rctx.file("BUILD.bazel", _BUILD_FILE_CONTENTS) rctx.template("requirements.bzl", rctx.attr._template, substitutions = { "%%ALL_DATA_REQUIREMENTS%%": render.list([ @@ -65,8 +59,6 @@ def _impl(rctx): for p in bzl_packages }), "%%MACRO_TMPL%%": macro_tmpl, - "%%PLATFORMS%%": render.indent(render.list(sorted(platforms))).lstrip(), - "%%PYTHON_VERSIONS%%": render.indent(render.list(sorted(rctx.attr.python_versions))).lstrip(), }) hub_repository = repository_rule( @@ -82,24 +74,6 @@ hub_repository = repository_rule( mandatory = False, doc = """\ The list of packages that will be exposed via all_*requirements macros. Defaults to whl_map keys. -""", - ), - # TODO @aignas 2025-03-23: get the `platforms` and `python_versions` - # from the aliases? This requires us to only create aliases for the - # target platforms and python_versions we care about. Python versions - # probably still need to be passed in. - "platforms": attr.string_list( - mandatory = True, - doc = """\ -The list of target platforms that are supported in this hub repository. This -can contain 'abi_os_arch' tuples or 'host' to keep the lock files os/arch -agnostic. -""", - ), - "python_versions": attr.string_list( - mandatory = True, - doc = """\ -The list of python versions that are supported in this hub repository. """, ), "repo_name": attr.string( diff --git a/python/private/pypi/requirements.bzl.tmpl.bzlmod b/python/private/pypi/requirements.bzl.tmpl.bzlmod index 3b1f7d4a11..ba227aeb2d 100644 --- a/python/private/pypi/requirements.bzl.tmpl.bzlmod +++ b/python/private/pypi/requirements.bzl.tmpl.bzlmod @@ -13,15 +13,6 @@ all_whl_requirements = all_whl_requirements_by_package.values() all_data_requirements = %%ALL_DATA_REQUIREMENTS%% -# Internal constants used for passing information to `whl_library` -# repositories without causing re-fetching. This is not intended to be -# a stable API and may break. If you would like to depend on it, please raise -# a ticket describing your use-case. -private = struct( - python_versions = %%PYTHON_VERSIONS%%, - platforms = %%PLATFORMS%%, -) - def requirement(name): return "%%MACRO_TMPL%%".format(pip_utils.normalize_name(name), "pkg") diff --git a/python/private/pypi/whl_library.bzl b/python/private/pypi/whl_library.bzl index b0ca532d3c..b6dbc3c2ae 100644 --- a/python/private/pypi/whl_library.bzl +++ b/python/private/pypi/whl_library.bzl @@ -21,6 +21,7 @@ load("//python/private:repo_utils.bzl", "REPO_DEBUG_ENV_VAR", "repo_utils") load(":attrs.bzl", "ATTRS", "use_isolated") load(":deps.bzl", "all_repo_names", "record_files") load(":generate_whl_library_build_bazel.bzl", "generate_whl_library_build_bazel") +load(":parse_requirements.bzl", "host_platform") load(":parse_whl_name.bzl", "parse_whl_name") load(":patch_whl.bzl", "patch_whl") load(":pypi_repo_utils.bzl", "pypi_repo_utils") @@ -353,7 +354,6 @@ def _whl_library_impl(rctx): entry_points[entry_point_without_py] = entry_point_script_name build_file_contents = generate_whl_library_build_bazel( - name = metadata["name"], whl_name = whl_path.basename, # TODO @aignas 2025-03-23: load the dep_template from the hub repository dep_template = rctx.attr.dep_template or "@{}{{name}}//:{{target}}".format(rctx.attr.repo_prefix), @@ -369,12 +369,25 @@ def _whl_library_impl(rctx): entry_points = entry_points, # TODO @aignas 2025-03-23: store the annotation in the hub repo. annotation = None if not rctx.attr.annotation else struct(**json.decode(rctx.read(rctx.attr.annotation))), + name = metadata["name"], requires_dist = metadata["requires_dist"], - # TODO @aignas 2025-03-23: we should just generate targets for all of the - # exposed extras and ask users to depend on this by `@pypi//foo:foo__extra`. - # Since all of the dependencies go through the `hub` repository, the extras - # that include packages that we don't + # target the host platform if the target platform is not specified in the rule. + # TODO @aignas 2025-03-23: we should materialize this inside the + # hub_repository `requirements.bzl` file as `TARGET_PLATFORMS` with a + # note, that this is internal and will be only for usage of the + # `whl_library` + platforms = target_platforms or [ + "{}_{}".format(metadata["abi"], host_platform(rctx)), + ], + # TODO @aignas 2025-03-23: we should expose the requested extras via a + # dict in `requirements.bzl` `EXTRAS` where the key is the package name + # and the value is the list of requested extras. like the above, for + # internal usage only. extras = metadata["extras"], + # TODO @aignas 2025-03-23: we should expose full python version via the + # TARGET_PYTHON_VERSIONS list so that we can correctly calculate the + # deps. This would be again, internal only stuff. + host_python_version = metadata["python_version"], ) rctx.file("BUILD.bazel", build_file_contents) diff --git a/python/private/pypi/whl_library_targets.bzl b/python/private/pypi/whl_library_targets.bzl index 169918eb16..3102f354a0 100644 --- a/python/private/pypi/whl_library_targets.bzl +++ b/python/private/pypi/whl_library_targets.bzl @@ -58,7 +58,6 @@ def whl_library_targets( copy_file = copy_file, py_binary = py_binary, py_library = py_library, - deps = deps, )): """Create all of the whl_library targets. @@ -102,7 +101,7 @@ def whl_library_targets( # the analysis phase. This means that we need to get the target platform abi # from the python version/versions we are setting the package up for. We can # potentially get this from the python toolchain interpreter. - package_deps = rules.deps( + package_deps = deps( name = name, requires_dist = requires_dist, platforms = platforms, @@ -113,6 +112,11 @@ def whl_library_targets( dependencies = package_deps.deps dependencies_by_platform = package_deps.deps_select + dependencies = sorted([normalize_name(d) for d in dependencies]) + dependencies_by_platform = { + platform: sorted([normalize_name(d) for d in deps]) + for platform, deps in dependencies_by_platform.items() + } tags = sorted(tags) data = [] + data From 81512d2ce8445a8ec9cc3091a23f10af664988d4 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Fri, 4 Apr 2025 09:34:51 +0900 Subject: [PATCH 48/65] Revert "move the dep parsing to the analysis phase" This reverts commit 7f99cb76977023cc36592a459f647c927fac5d46. --- .../pypi/generate_whl_library_build_bazel.bzl | 3 -- python/private/pypi/whl_library.bzl | 46 ++++++++++++------- python/private/pypi/whl_library_targets.bzl | 36 +++------------ 3 files changed, 37 insertions(+), 48 deletions(-) diff --git a/python/private/pypi/generate_whl_library_build_bazel.bzl b/python/private/pypi/generate_whl_library_build_bazel.bzl index 977b4d2377..8050cd22ad 100644 --- a/python/private/pypi/generate_whl_library_build_bazel.bzl +++ b/python/private/pypi/generate_whl_library_build_bazel.bzl @@ -24,10 +24,7 @@ _RENDER = { "dependencies": render.list, "dependencies_by_platform": lambda x: render.dict(x, value_repr = render.list), "entry_points": render.dict, - "extras": render.list, "group_deps": render.list, - "platforms": render.list, - "requires_dist": render.list, "srcs_exclude": render.list, "tags": render.list, } diff --git a/python/private/pypi/whl_library.bzl b/python/private/pypi/whl_library.bzl index b6dbc3c2ae..72d6821939 100644 --- a/python/private/pypi/whl_library.bzl +++ b/python/private/pypi/whl_library.bzl @@ -24,6 +24,7 @@ load(":generate_whl_library_build_bazel.bzl", "generate_whl_library_build_bazel" load(":parse_requirements.bzl", "host_platform") load(":parse_whl_name.bzl", "parse_whl_name") load(":patch_whl.bzl", "patch_whl") +load(":pep508_env.bzl", "deps") load(":pypi_repo_utils.bzl", "pypi_repo_utils") load(":whl_target_platforms.bzl", "whl_target_platforms") @@ -353,22 +354,13 @@ def _whl_library_impl(rctx): ) entry_points[entry_point_without_py] = entry_point_script_name - build_file_contents = generate_whl_library_build_bazel( - whl_name = whl_path.basename, - # TODO @aignas 2025-03-23: load the dep_template from the hub repository - dep_template = rctx.attr.dep_template or "@{}{{name}}//:{{target}}".format(rctx.attr.repo_prefix), - # TODO @aignas 2025-03-23: store the `group_name` per package in the hub repo - group_name = rctx.attr.group_name, - group_deps = rctx.attr.group_deps, - # TODO @aignas 2025-03-23: store the pip_data_exclude in the hub repo. - data_exclude = rctx.attr.pip_data_exclude, - tags = [ - "pypi_name=" + metadata["name"], - "pypi_version=" + metadata["version"], - ], - entry_points = entry_points, - # TODO @aignas 2025-03-23: store the annotation in the hub repo. - annotation = None if not rctx.attr.annotation else struct(**json.decode(rctx.read(rctx.attr.annotation))), + # TODO @aignas 2025-02-24: move this to pkg_aliases layer to have this in + # the analysis phase. This means that we need to get the target platform abi + # from the python version/versions we are setting the package up for. We can + # potentially get this from the python toolchain interpreter. + package_deps = deps( + # TODO @aignas 2025-02-24: get the data here by parsing the METADATA + # file manually without involving python interpreter at all. name = metadata["name"], requires_dist = metadata["requires_dist"], # target the host platform if the target platform is not specified in the rule. @@ -389,6 +381,28 @@ def _whl_library_impl(rctx): # deps. This would be again, internal only stuff. host_python_version = metadata["python_version"], ) + + build_file_contents = generate_whl_library_build_bazel( + name = whl_path.basename, + # TODO @aignas 2025-03-23: load the dep_template from the hub repository + dep_template = rctx.attr.dep_template or "@{}{{name}}//:{{target}}".format(rctx.attr.repo_prefix), + # TODO @aignas 2025-03-23: replace `dependencies` and + # `dependencies_by_platform` with `requires_dist`. + dependencies = package_deps.deps, + dependencies_by_platform = package_deps.deps_select, + # TODO @aignas 2025-03-23: store the `group_name` per package in the hub repo + group_name = rctx.attr.group_name, + group_deps = rctx.attr.group_deps, + # TODO @aignas 2025-03-23: store the pip_data_exclude in the hub repo. + data_exclude = rctx.attr.pip_data_exclude, + tags = [ + "pypi_name=" + metadata["name"], + "pypi_version=" + metadata["version"], + ], + entry_points = entry_points, + # TODO @aignas 2025-03-23: store the annotation in the hub repo. + annotation = None if not rctx.attr.annotation else struct(**json.decode(rctx.read(rctx.attr.annotation))), + ) rctx.file("BUILD.bazel", build_file_contents) return diff --git a/python/private/pypi/whl_library_targets.bzl b/python/private/pypi/whl_library_targets.bzl index 3102f354a0..38ed57d0d2 100644 --- a/python/private/pypi/whl_library_targets.bzl +++ b/python/private/pypi/whl_library_targets.bzl @@ -29,12 +29,10 @@ load( "WHEEL_FILE_IMPL_LABEL", "WHEEL_FILE_PUBLIC_LABEL", ) -load(":pep508_env.bzl", "deps") def whl_library_targets( *, name, - whl_name, dep_template, data_exclude = [], srcs_exclude = [], @@ -43,16 +41,14 @@ def whl_library_targets( DIST_INFO_LABEL: ["site-packages/*.dist-info/**"], DATA_LABEL: ["data/**"], }, + dependencies = [], + dependencies_by_platform = {}, group_deps = [], group_name = "", data = [], copy_files = {}, copy_executables = {}, entry_points = {}, - requires_dist = [], - platforms, - extras = [], - host_python_version, native = native, rules = struct( copy_file = copy_file, @@ -62,12 +58,14 @@ def whl_library_targets( """Create all of the whl_library targets. Args: - name: {type}`str` the name of the distribution. - whl_name: {type}`str` The file to match for including it into the `whl` + name: {type}`str` The file to match for including it into the `whl` filegroup. This may be also parsed to generate extra metadata. dep_template: {type}`str` The dep_template to use for dependency interpolation. tags: {type}`list[str]` The tags set on the `py_library`. + dependencies: {type}`list[str]` A list of dependencies. + dependencies_by_platform: {type}`dict[str, list[str]]` A list of + dependencies by platform key. filegroups: {type}`dict[str, list[str]]` A dictionary of the target names and the glob matches. group_name: {type}`str` name of the dependency group (if any) which @@ -89,29 +87,9 @@ def whl_library_targets( data: {type}`list[str]` A list of labels to include as part of the `data` attribute in `py_library`. entry_points: {type}`dict[str, str]` The mapping between the script name and the python file to use. DEPRECATED. - requires_dist: TODO - platforms: TODO - extras: TODO - host_python_version: TODO native: {type}`native` The native struct for overriding in tests. rules: {type}`struct` A struct with references to rules for creating targets. """ - - # TODO @aignas 2025-02-24: move this to pkg_aliases layer to have this in - # the analysis phase. This means that we need to get the target platform abi - # from the python version/versions we are setting the package up for. We can - # potentially get this from the python toolchain interpreter. - package_deps = deps( - name = name, - requires_dist = requires_dist, - platforms = platforms, - extras = extras, - host_python_version = host_python_version, - ) - - dependencies = package_deps.deps - dependencies_by_platform = package_deps.deps_select - dependencies = sorted([normalize_name(d) for d in dependencies]) dependencies_by_platform = { platform: sorted([normalize_name(d) for d in deps]) @@ -225,7 +203,7 @@ def whl_library_targets( if hasattr(native, "filegroup"): native.filegroup( name = whl_file_label, - srcs = [whl_name], + srcs = [name], data = _deps( deps = dependencies, deps_by_platform = dependencies_by_platform, From 24537e9bfcd4d95b5ba205bb23c57bac67ecda45 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Fri, 4 Apr 2025 10:04:49 +0900 Subject: [PATCH 49/65] fixup tests --- tests/pypi/whl_installer/BUILD.bazel | 24 -- tests/pypi/whl_installer/arguments_test.py | 14 +- .../whl_installer/wheel_installer_test.py | 7 +- tests/pypi/whl_installer/wheel_test.py | 371 ------------------ 4 files changed, 5 insertions(+), 411 deletions(-) delete mode 100644 tests/pypi/whl_installer/wheel_test.py diff --git a/tests/pypi/whl_installer/BUILD.bazel b/tests/pypi/whl_installer/BUILD.bazel index 040e4d765f..fea6a46d01 100644 --- a/tests/pypi/whl_installer/BUILD.bazel +++ b/tests/pypi/whl_installer/BUILD.bazel @@ -27,18 +27,6 @@ py_test( ], ) -py_test( - name = "platform_test", - size = "small", - srcs = [ - "platform_test.py", - ], - data = ["//examples/wheel:minimal_with_py_package"], - deps = [ - ":lib", - ], -) - py_test( name = "wheel_installer_test", size = "small", @@ -50,15 +38,3 @@ py_test( ":lib", ], ) - -py_test( - name = "wheel_test", - size = "small", - srcs = [ - "wheel_test.py", - ], - data = ["//examples/wheel:minimal_with_py_package"], - deps = [ - ":lib", - ], -) diff --git a/tests/pypi/whl_installer/arguments_test.py b/tests/pypi/whl_installer/arguments_test.py index 5538054a59..9f73ae96a9 100644 --- a/tests/pypi/whl_installer/arguments_test.py +++ b/tests/pypi/whl_installer/arguments_test.py @@ -15,7 +15,7 @@ import json import unittest -from python.private.pypi.whl_installer import arguments, wheel +from python.private.pypi.whl_installer import arguments class ArgumentsTestCase(unittest.TestCase): @@ -49,18 +49,6 @@ def test_deserialize_structured_args(self) -> None: self.assertEqual(args["environment"], {"PIP_DO_SOMETHING": "True"}) self.assertEqual(args["extra_pip_args"], []) - def test_platform_aggregation(self) -> None: - parser = arguments.parser() - args = parser.parse_args( - args=[ - "--platform=linux_*", - "--platform=osx_*", - "--platform=windows_*", - "--requirement=foo", - ] - ) - self.assertEqual(set(wheel.Platform.all()), arguments.get_platforms(args)) - if __name__ == "__main__": unittest.main() diff --git a/tests/pypi/whl_installer/wheel_installer_test.py b/tests/pypi/whl_installer/wheel_installer_test.py index 7139779c3e..09affc99fd 100644 --- a/tests/pypi/whl_installer/wheel_installer_test.py +++ b/tests/pypi/whl_installer/wheel_installer_test.py @@ -71,7 +71,6 @@ def test_wheel_exists(self) -> None: installation_dir=Path(self.wheel_dir), extras={}, enable_implicit_namespace_pkgs=False, - platforms=[], ) want_files = [ @@ -92,11 +91,13 @@ def test_wheel_exists(self) -> None: metadata_file_content = json.load(metadata_file) want = dict( + abi="cp311", version="0.0.1", name="example-minimal-package", - deps=[], - deps_by_platform={}, entry_points=[], + extras=[], + python_version="3.11.1", + requires_dist=[], ) self.assertEqual(want, metadata_file_content) diff --git a/tests/pypi/whl_installer/wheel_test.py b/tests/pypi/whl_installer/wheel_test.py deleted file mode 100644 index 404218e12b..0000000000 --- a/tests/pypi/whl_installer/wheel_test.py +++ /dev/null @@ -1,371 +0,0 @@ -import unittest -from unittest import mock - -from python.private.pypi.whl_installer import wheel -from python.private.pypi.whl_installer.platform import OS, Arch, Platform - -_HOST_INTERPRETER_FN = ( - "python.private.pypi.whl_installer.wheel.host_interpreter_minor_version" -) - - -class DepsTest(unittest.TestCase): - def test_simple(self): - deps = wheel.Deps("foo", requires_dist=["bar"]) - - got = deps.build() - - self.assertIsInstance(got, wheel.FrozenDeps) - self.assertEqual(["bar"], got.deps) - self.assertEqual({}, got.deps_select) - - def test_can_add_os_specific_deps(self): - deps = wheel.Deps( - "foo", - requires_dist=[ - "bar", - "an_osx_dep; sys_platform=='darwin'", - "posix_dep; os_name=='posix'", - "win_dep; os_name=='nt'", - ], - platforms={ - Platform(os=OS.linux, arch=Arch.x86_64), - Platform(os=OS.osx, arch=Arch.x86_64), - Platform(os=OS.osx, arch=Arch.aarch64), - Platform(os=OS.windows, arch=Arch.x86_64), - }, - ) - - got = deps.build() - - self.assertEqual(["bar"], got.deps) - self.assertEqual( - { - "@platforms//os:linux": ["posix_dep"], - "@platforms//os:osx": ["an_osx_dep", "posix_dep"], - "@platforms//os:windows": ["win_dep"], - }, - got.deps_select, - ) - - def test_can_add_os_specific_deps_with_specific_python_version(self): - deps = wheel.Deps( - "foo", - requires_dist=[ - "bar", - "an_osx_dep; sys_platform=='darwin'", - "posix_dep; os_name=='posix'", - "win_dep; os_name=='nt'", - ], - platforms={ - Platform(os=OS.linux, arch=Arch.x86_64, minor_version=8), - Platform(os=OS.osx, arch=Arch.x86_64, minor_version=8), - Platform(os=OS.osx, arch=Arch.aarch64, minor_version=8), - Platform(os=OS.windows, arch=Arch.x86_64, minor_version=8), - }, - ) - - got = deps.build() - - self.assertEqual(["bar"], got.deps) - self.assertEqual( - { - "@platforms//os:linux": ["posix_dep"], - "@platforms//os:osx": ["an_osx_dep", "posix_dep"], - "@platforms//os:windows": ["win_dep"], - }, - got.deps_select, - ) - - def test_deps_are_added_to_more_specialized_platforms(self): - got = wheel.Deps( - "foo", - requires_dist=[ - "m1_dep; sys_platform=='darwin' and platform_machine=='arm64'", - "mac_dep; sys_platform=='darwin'", - ], - platforms={ - Platform(os=OS.osx, arch=Arch.x86_64), - Platform(os=OS.osx, arch=Arch.aarch64), - }, - ).build() - - self.assertEqual( - wheel.FrozenDeps( - deps=[], - deps_select={ - "osx_aarch64": ["m1_dep", "mac_dep"], - "@platforms//os:osx": ["mac_dep"], - }, - ), - got, - ) - - def test_deps_from_more_specialized_platforms_are_propagated(self): - got = wheel.Deps( - "foo", - requires_dist=[ - "a_mac_dep; sys_platform=='darwin'", - "m1_dep; sys_platform=='darwin' and platform_machine=='arm64'", - ], - platforms={ - Platform(os=OS.osx, arch=Arch.x86_64), - Platform(os=OS.osx, arch=Arch.aarch64), - }, - ).build() - - self.assertEqual([], got.deps) - self.assertEqual( - { - "osx_aarch64": ["a_mac_dep", "m1_dep"], - "@platforms//os:osx": ["a_mac_dep"], - }, - got.deps_select, - ) - - def test_non_platform_markers_are_added_to_common_deps(self): - got = wheel.Deps( - "foo", - requires_dist=[ - "bar", - "baz; implementation_name=='cpython'", - "m1_dep; sys_platform=='darwin' and platform_machine=='arm64'", - ], - platforms={ - Platform(os=OS.linux, arch=Arch.x86_64), - Platform(os=OS.osx, arch=Arch.x86_64), - Platform(os=OS.osx, arch=Arch.aarch64), - Platform(os=OS.windows, arch=Arch.x86_64), - }, - ).build() - - self.assertEqual(["bar", "baz"], got.deps) - self.assertEqual( - { - "osx_aarch64": ["m1_dep"], - }, - got.deps_select, - ) - - def test_self_is_ignored(self): - deps = wheel.Deps( - "foo", - requires_dist=[ - "bar", - "req_dep; extra == 'requests'", - "foo[requests]; extra == 'ssl'", - "ssl_lib; extra == 'ssl'", - ], - extras={"ssl"}, - ) - - got = deps.build() - - self.assertEqual(["bar", "req_dep", "ssl_lib"], got.deps) - self.assertEqual({}, got.deps_select) - - def test_self_dependencies_can_come_in_any_order(self): - deps = wheel.Deps( - "foo", - requires_dist=[ - "bar", - "baz; extra == 'feat'", - "foo[feat2]; extra == 'all'", - "foo[feat]; extra == 'feat2'", - "zdep; extra == 'all'", - ], - extras={"all"}, - ) - - got = deps.build() - - self.assertEqual(["bar", "baz", "zdep"], got.deps) - self.assertEqual({}, got.deps_select) - - def test_can_get_deps_based_on_specific_python_version(self): - requires_dist = [ - "bar", - "baz; python_version < '3.8'", - "posix_dep; os_name=='posix' and python_version >= '3.8'", - ] - - py38_deps = wheel.Deps( - "foo", - requires_dist=requires_dist, - platforms=[ - Platform(os=OS.linux, arch=Arch.x86_64, minor_version=8), - ], - ).build() - py37_deps = wheel.Deps( - "foo", - requires_dist=requires_dist, - platforms=[ - Platform(os=OS.linux, arch=Arch.x86_64, minor_version=7), - ], - ).build() - - self.assertEqual(["bar", "baz"], py37_deps.deps) - self.assertEqual({}, py37_deps.deps_select) - self.assertEqual(["bar"], py38_deps.deps) - self.assertEqual({"@platforms//os:linux": ["posix_dep"]}, py38_deps.deps_select) - - @mock.patch(_HOST_INTERPRETER_FN) - def test_no_version_select_when_single_version(self, mock_host_interpreter_version): - requires_dist = [ - "bar", - "baz; python_version >= '3.8'", - "posix_dep; os_name=='posix'", - "posix_dep_with_version; os_name=='posix' and python_version >= '3.8'", - "arch_dep; platform_machine=='x86_64' and python_version >= '3.8'", - ] - mock_host_interpreter_version.return_value = 7 - - self.maxDiff = None - - deps = wheel.Deps( - "foo", - requires_dist=requires_dist, - platforms=[ - Platform(os=os, arch=Arch.x86_64, minor_version=minor) - for minor in [8] - for os in [OS.linux, OS.windows] - ], - ) - got = deps.build() - - self.assertEqual(["bar", "baz"], got.deps) - self.assertEqual( - { - "@platforms//os:linux": ["posix_dep", "posix_dep_with_version"], - "linux_x86_64": ["arch_dep", "posix_dep", "posix_dep_with_version"], - "windows_x86_64": ["arch_dep"], - }, - got.deps_select, - ) - - @mock.patch(_HOST_INTERPRETER_FN) - def test_can_get_version_select(self, mock_host_interpreter_version): - requires_dist = [ - "bar", - "baz; python_version < '3.8'", - "baz_new; python_version >= '3.8'", - "posix_dep; os_name=='posix'", - "posix_dep_with_version; os_name=='posix' and python_version >= '3.8'", - "arch_dep; platform_machine=='x86_64' and python_version < '3.8'", - ] - mock_host_interpreter_version.return_value = 7 - - self.maxDiff = None - - deps = wheel.Deps( - "foo", - requires_dist=requires_dist, - platforms=[ - Platform(os=os, arch=Arch.x86_64, minor_version=minor) - for minor in [7, 8, 9] - for os in [OS.linux, OS.windows] - ], - ) - got = deps.build() - - self.assertEqual(["bar"], got.deps) - self.assertEqual( - { - "//conditions:default": ["baz"], - "@//python/config_settings:is_python_3.7": ["baz"], - "@//python/config_settings:is_python_3.8": ["baz_new"], - "@//python/config_settings:is_python_3.9": ["baz_new"], - "@platforms//os:linux": ["baz", "posix_dep"], - "cp37_linux_x86_64": ["arch_dep", "baz", "posix_dep"], - "cp37_windows_x86_64": ["arch_dep", "baz"], - "cp37_linux_anyarch": ["baz", "posix_dep"], - "cp38_linux_anyarch": [ - "baz_new", - "posix_dep", - "posix_dep_with_version", - ], - "cp39_linux_anyarch": [ - "baz_new", - "posix_dep", - "posix_dep_with_version", - ], - "linux_x86_64": ["arch_dep", "baz", "posix_dep"], - "windows_x86_64": ["arch_dep", "baz"], - }, - got.deps_select, - ) - - @mock.patch(_HOST_INTERPRETER_FN) - def test_deps_spanning_all_target_py_versions_are_added_to_common( - self, mock_host_version - ): - requires_dist = [ - "bar", - "baz (<2,>=1.11) ; python_version < '3.8'", - "baz (<2,>=1.14) ; python_version >= '3.8'", - ] - mock_host_version.return_value = 8 - - deps = wheel.Deps( - "foo", - requires_dist=requires_dist, - platforms=Platform.from_string(["cp37_*", "cp38_*", "cp39_*"]), - ) - got = deps.build() - - self.assertEqual(["bar", "baz"], got.deps) - self.assertEqual({}, got.deps_select) - - @mock.patch(_HOST_INTERPRETER_FN) - def test_deps_are_not_duplicated(self, mock_host_version): - mock_host_version.return_value = 7 - - # See an example in - # https://files.pythonhosted.org/packages/76/9e/db1c2d56c04b97981c06663384f45f28950a73d9acf840c4006d60d0a1ff/opencv_python-4.9.0.80-cp37-abi3-win32.whl.metadata - requires_dist = [ - "bar >=0.1.0 ; python_version < '3.7'", - "bar >=0.2.0 ; python_version >= '3.7'", - "bar >=0.4.0 ; python_version >= '3.6' and platform_system == 'Linux' and platform_machine == 'aarch64'", - "bar >=0.4.0 ; python_version >= '3.9'", - "bar >=0.5.0 ; python_version <= '3.9' and platform_system == 'Darwin' and platform_machine == 'arm64'", - "bar >=0.5.0 ; python_version >= '3.10' and platform_system == 'Darwin'", - "bar >=0.5.0 ; python_version >= '3.10'", - "bar >=0.6.0 ; python_version >= '3.11'", - ] - - deps = wheel.Deps( - "foo", - requires_dist=requires_dist, - platforms=Platform.from_string(["cp37_*", "cp310_*"]), - ) - got = deps.build() - - self.assertEqual(["bar"], got.deps) - self.assertEqual({}, got.deps_select) - - @mock.patch(_HOST_INTERPRETER_FN) - def test_deps_are_not_duplicated_when_encountering_platform_dep_first( - self, mock_host_version - ): - mock_host_version.return_value = 7 - - # Note, that we are sorting the incoming `requires_dist` and we need to ensure that we are not getting any - # issues even if the platform-specific line comes first. - requires_dist = [ - "bar >=0.4.0 ; python_version >= '3.6' and platform_system == 'Linux' and platform_machine == 'aarch64'", - "bar >=0.5.0 ; python_version >= '3.9'", - ] - - deps = wheel.Deps( - "foo", - requires_dist=requires_dist, - platforms=Platform.from_string(["cp37_*", "cp310_*"]), - ) - got = deps.build() - - self.assertEqual(["bar"], got.deps) - self.assertEqual({}, got.deps_select) - - -if __name__ == "__main__": - unittest.main() From eb1c0a1b70ee714b6295a1006588811cbf721200 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Fri, 4 Apr 2025 13:26:29 +0900 Subject: [PATCH 50/65] add some notes --- python/private/pypi/whl_library.bzl | 54 ++++++++++++++++------------- 1 file changed, 30 insertions(+), 24 deletions(-) diff --git a/python/private/pypi/whl_library.bzl b/python/private/pypi/whl_library.bzl index d8aaf50e74..1414710539 100644 --- a/python/private/pypi/whl_library.bzl +++ b/python/private/pypi/whl_library.bzl @@ -394,53 +394,59 @@ def _whl_library_impl(rctx): ) entry_points[entry_point_without_py] = entry_point_script_name - # TODO @aignas 2025-02-24: move this to pkg_aliases layer to have this in - # the analysis phase. This means that we need to get the target platform abi - # from the python version/versions we are setting the package up for. We can - # potentially get this from the python toolchain interpreter. + # TODO @aignas 2025-04-04: move this to whl_library_targets.bzl to have + # this in the analysis phase. + # + # This means that whl_library_targets will have to accept the following args: + # * name - the name of the package in the METADATA. + # * requires_dist - the list of METADATA RequiresDist. + # * platforms - the list of target platforms. The target_platforms + # should come from the hub repo via a 'load' statement so that they don't + # need to be passed as an argument to `whl_library`. + # * extras - the list of required extras. This comes from the + # `rctx.attr.requirement` for now. In the future the required extras could + # stay in the hub repo, where we calculate the extra aliases that we need + # to create automatically and this way expose the targets for the specific + # extras. The first step will be to generate a target per extra for the + # `py_library` and `filegroup`. Maybe we need to have a special provider + # or an output group so that we can return the `whl` file from the + # `py_library` target? filegroup can use output groups to expose files. + # * host_python_version/versons - the list of python versions to support + # should come from the hub, similar to how the target platforms are specified. + # + # Extra things that we should move at the same time: + # * group_name, group_deps - this info can stay in the hub repository so that + # it is piped at the analysis time and changing the requirement groups does + # cause to re-fetch the deps. package_deps = deps( - # TODO @aignas 2025-02-24: get the data here by parsing the METADATA - # file manually without involving python interpreter at all. + # TODO @aignas 2025-04-04: get the following from manually parsing + # METADATA to avoid Python dependency: + # * name of the package + # * version of the package + # * RequiresDist + # * ProvidesExtras name = metadata["name"], requires_dist = metadata["requires_dist"], - # target the host platform if the target platform is not specified in the rule. - # TODO @aignas 2025-03-23: we should materialize this inside the - # hub_repository `requirements.bzl` file as `TARGET_PLATFORMS` with a - # note, that this is internal and will be only for usage of the - # `whl_library` platforms = target_platforms or [ "{}_{}".format(metadata["abi"], host_platform(rctx)), ], - # TODO @aignas 2025-03-23: we should expose the requested extras via a - # dict in `requirements.bzl` `EXTRAS` where the key is the package name - # and the value is the list of requested extras. like the above, for - # internal usage only. extras = metadata["extras"], - # TODO @aignas 2025-03-23: we should expose full python version via the - # TARGET_PYTHON_VERSIONS list so that we can correctly calculate the - # deps. This would be again, internal only stuff. host_python_version = metadata["python_version"], ) build_file_contents = generate_whl_library_build_bazel( name = whl_path.basename, - # TODO @aignas 2025-03-23: load the dep_template from the hub repository dep_template = rctx.attr.dep_template or "@{}{{name}}//:{{target}}".format(rctx.attr.repo_prefix), - # TODO @aignas 2025-03-23: replace `dependencies` and - # `dependencies_by_platform` with `requires_dist`. dependencies = package_deps.deps, dependencies_by_platform = package_deps.deps_select, - # TODO @aignas 2025-03-23: store the `group_name` per package in the hub repo group_name = rctx.attr.group_name, group_deps = rctx.attr.group_deps, - # TODO @aignas 2025-03-23: store the pip_data_exclude in the hub repo. data_exclude = rctx.attr.pip_data_exclude, tags = [ "pypi_name=" + metadata["name"], "pypi_version=" + metadata["version"], ], entry_points = entry_points, - # TODO @aignas 2025-03-23: store the annotation in the hub repo. annotation = None if not rctx.attr.annotation else struct(**json.decode(rctx.read(rctx.attr.annotation))), ) rctx.file("BUILD.bazel", build_file_contents) From a570e1aae81f9961dfb208fa6fe7d43c44167132 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Fri, 4 Apr 2025 17:19:49 +0900 Subject: [PATCH 51/65] fix(python): correctly order the toolchains Since toolchain matching is done by matching the first target that matches target settings, the `minor_mapping` config setting is special, because e.g. all `3.11.X` toolchains match the `python_version = "3.11"` setting. This just reshuffles the list so that we have toolchains that are in the `minor_mapping` before the rest. Fixes #2685 --- python/private/python.bzl | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/python/private/python.bzl b/python/private/python.bzl index 44eb09f766..9e645579a8 100644 --- a/python/private/python.bzl +++ b/python/private/python.bzl @@ -243,6 +243,18 @@ def parse_modules(*, module_ctx, _fail = fail): if len(toolchains) > _MAX_NUM_TOOLCHAINS: fail("more than {} python versions are not supported".format(_MAX_NUM_TOOLCHAINS)) + # sort the toolchains so that the toolchain versions that are in the + # `minor_mapping` are coming first. This ensures that `python_version = + # "3.X"` transitions work as expected. + minor_version_toolchains = [] + other_toolchains = [] + for t in toolchains: + if t.python_version in config.minor_mapping: + minor_version_toolchains.append(t) + else: + other_toolchains.append(t) + toolchains = minor_version_toolchains + other_toolchains + return struct( config = config, debug_info = debug_info, From 3a502392f17297c8290791cb6552500abef961c1 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Fri, 4 Apr 2025 17:22:45 +0900 Subject: [PATCH 52/65] fix the python version --- tests/pypi/whl_installer/wheel_installer_test.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/pypi/whl_installer/wheel_installer_test.py b/tests/pypi/whl_installer/wheel_installer_test.py index 09affc99fd..690c408981 100644 --- a/tests/pypi/whl_installer/wheel_installer_test.py +++ b/tests/pypi/whl_installer/wheel_installer_test.py @@ -96,7 +96,7 @@ def test_wheel_exists(self) -> None: name="example-minimal-package", entry_points=[], extras=[], - python_version="3.11.1", + python_version="3.11.11", requires_dist=[], ) self.assertEqual(want, metadata_file_content) From e8b290a89a0c10d60433b4c57b25f1377ad69b46 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sat, 5 Apr 2025 23:25:15 +0900 Subject: [PATCH 53/65] fix env marker evaluation with double brackets --- python/private/pypi/pep508_evaluate.bzl | 12 +++++++++--- tests/pypi/pep508/evaluate_tests.bzl | 2 ++ 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/python/private/pypi/pep508_evaluate.bzl b/python/private/pypi/pep508_evaluate.bzl index ae273d4d37..f8ef553034 100644 --- a/python/private/pypi/pep508_evaluate.bzl +++ b/python/private/pypi/pep508_evaluate.bzl @@ -138,7 +138,7 @@ def evaluate(marker, *, env, strict = True, **kwargs): """ tokens = tokenize(marker) - ast = _new_expr(**kwargs) + ast = _new_expr(marker = marker, **kwargs) for _ in range(len(tokens) * 2): if not tokens: break @@ -219,17 +219,20 @@ def _not_fn(x): return not x def _new_expr( + *, + marker, and_fn = _and_fn, or_fn = _or_fn, not_fn = _not_fn): # buildifier: disable=uninitialized self = struct( + marker = marker, tree = [], parse = lambda **kwargs: _parse(self, **kwargs), value = lambda: _value(self), # This is a way for us to have a handle to the currently constructed # expression tree branch. - current = lambda: self._current[0] if self._current else None, + current = lambda: self._current[-1] if self._current else None, _current = [], _and = and_fn, _or = or_fn, @@ -393,12 +396,15 @@ def _append(self, value): current.tree.append(value) elif hasattr(current.tree[-1], "append"): current.tree[-1].append(value) - else: + elif hasattr(current.tree, "_append"): current.tree._append(value) + else: + fail("Cannot evaluate '{}' in '{}', current: {}".format(value, self.marker, current)) def _open_parenthesis(self): """Add an extra node into the tree to perform evaluate inside parenthesis.""" self._current.append(_new_expr( + marker = self.marker, and_fn = self._and, or_fn = self._or, not_fn = self._not, diff --git a/tests/pypi/pep508/evaluate_tests.bzl b/tests/pypi/pep508/evaluate_tests.bzl index 80b70f4dad..14e5e40b43 100644 --- a/tests/pypi/pep508/evaluate_tests.bzl +++ b/tests/pypi/pep508/evaluate_tests.bzl @@ -148,6 +148,8 @@ def _logical_expression_tests(env): # expr "os_name == 'fo'": False, "(os_name == 'fo')": False, + "((os_name == 'fo'))": False, + "((os_name == 'foo'))": True, "not (os_name == 'fo')": True, # and From 484f8ef63bcafe8289f1b5024f987057558d13a3 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sat, 5 Apr 2025 23:35:15 +0900 Subject: [PATCH 54/65] remove unused platform test --- tests/pypi/whl_installer/platform_test.py | 154 ---------------------- 1 file changed, 154 deletions(-) delete mode 100644 tests/pypi/whl_installer/platform_test.py diff --git a/tests/pypi/whl_installer/platform_test.py b/tests/pypi/whl_installer/platform_test.py deleted file mode 100644 index 2aeb4caa69..0000000000 --- a/tests/pypi/whl_installer/platform_test.py +++ /dev/null @@ -1,154 +0,0 @@ -import unittest -from random import shuffle - -from python.private.pypi.whl_installer.platform import ( - OS, - Arch, - Platform, - host_interpreter_minor_version, -) - - -class MinorVersionTest(unittest.TestCase): - def test_host(self): - host = host_interpreter_minor_version() - self.assertIsNotNone(host) - - -class PlatformTest(unittest.TestCase): - def test_can_get_host(self): - host = Platform.host() - self.assertIsNotNone(host) - self.assertEqual(1, len(Platform.from_string("host"))) - self.assertEqual(host, Platform.from_string("host")) - - def test_can_get_linux_x86_64_without_py_version(self): - got = Platform.from_string("linux_x86_64") - want = Platform(os=OS.linux, arch=Arch.x86_64) - self.assertEqual(want, got[0]) - - def test_can_get_specific_from_string(self): - got = Platform.from_string("cp33_linux_x86_64") - want = Platform(os=OS.linux, arch=Arch.x86_64, minor_version=3) - self.assertEqual(want, got[0]) - - def test_can_get_all_for_py_version(self): - cp39 = Platform.all(minor_version=9) - self.assertEqual(21, len(cp39), f"Got {cp39}") - self.assertEqual(cp39, Platform.from_string("cp39_*")) - - def test_can_get_all_for_os(self): - linuxes = Platform.all(OS.linux, minor_version=9) - self.assertEqual(7, len(linuxes)) - self.assertEqual(linuxes, Platform.from_string("cp39_linux_*")) - - def test_can_get_all_for_os_for_host_python(self): - linuxes = Platform.all(OS.linux) - self.assertEqual(7, len(linuxes)) - self.assertEqual(linuxes, Platform.from_string("linux_*")) - - def test_specific_version_specializations(self): - any_py33 = Platform(minor_version=3) - - # When - all_specializations = list(any_py33.all_specializations()) - - want = ( - [any_py33] - + [ - Platform(arch=arch, minor_version=any_py33.minor_version) - for arch in Arch - ] - + [Platform(os=os, minor_version=any_py33.minor_version) for os in OS] - + Platform.all(minor_version=any_py33.minor_version) - ) - self.assertEqual(want, all_specializations) - - def test_aarch64_specializations(self): - any_aarch64 = Platform(arch=Arch.aarch64) - all_specializations = list(any_aarch64.all_specializations()) - want = [ - Platform(os=None, arch=Arch.aarch64), - Platform(os=OS.linux, arch=Arch.aarch64), - Platform(os=OS.osx, arch=Arch.aarch64), - Platform(os=OS.windows, arch=Arch.aarch64), - ] - self.assertEqual(want, all_specializations) - - def test_linux_specializations(self): - any_linux = Platform(os=OS.linux) - all_specializations = list(any_linux.all_specializations()) - want = [ - Platform(os=OS.linux, arch=None), - Platform(os=OS.linux, arch=Arch.x86_64), - Platform(os=OS.linux, arch=Arch.x86_32), - Platform(os=OS.linux, arch=Arch.aarch64), - Platform(os=OS.linux, arch=Arch.ppc), - Platform(os=OS.linux, arch=Arch.ppc64le), - Platform(os=OS.linux, arch=Arch.s390x), - Platform(os=OS.linux, arch=Arch.arm), - ] - self.assertEqual(want, all_specializations) - - def test_osx_specializations(self): - any_osx = Platform(os=OS.osx) - all_specializations = list(any_osx.all_specializations()) - # NOTE @aignas 2024-01-14: even though in practice we would only have - # Python on osx aarch64 and osx x86_64, we return all arch posibilities - # to make the code simpler. - want = [ - Platform(os=OS.osx, arch=None), - Platform(os=OS.osx, arch=Arch.x86_64), - Platform(os=OS.osx, arch=Arch.x86_32), - Platform(os=OS.osx, arch=Arch.aarch64), - Platform(os=OS.osx, arch=Arch.ppc), - Platform(os=OS.osx, arch=Arch.ppc64le), - Platform(os=OS.osx, arch=Arch.s390x), - Platform(os=OS.osx, arch=Arch.arm), - ] - self.assertEqual(want, all_specializations) - - def test_platform_sort(self): - platforms = [ - Platform(os=OS.linux, arch=None), - Platform(os=OS.linux, arch=Arch.x86_64), - Platform(os=OS.osx, arch=None), - Platform(os=OS.osx, arch=Arch.x86_64), - Platform(os=OS.osx, arch=Arch.aarch64), - ] - shuffle(platforms) - platforms.sort() - want = [ - Platform(os=OS.linux, arch=None), - Platform(os=OS.linux, arch=Arch.x86_64), - Platform(os=OS.osx, arch=None), - Platform(os=OS.osx, arch=Arch.x86_64), - Platform(os=OS.osx, arch=Arch.aarch64), - ] - - self.assertEqual(want, platforms) - - def test_wheel_os_alias(self): - self.assertEqual("osx", str(OS.osx)) - self.assertEqual(str(OS.darwin), str(OS.osx)) - - def test_wheel_arch_alias(self): - self.assertEqual("x86_64", str(Arch.x86_64)) - self.assertEqual(str(Arch.amd64), str(Arch.x86_64)) - - def test_wheel_platform_alias(self): - give = Platform( - os=OS.darwin, - arch=Arch.amd64, - ) - alias = Platform( - os=OS.osx, - arch=Arch.x86_64, - ) - - self.assertEqual("osx_x86_64", str(give)) - self.assertEqual(str(alias), str(give)) - - -if __name__ == "__main__": - unittest.main() From 15951549db0de9d52302b7653e167b71a8ac4f06 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 6 Apr 2025 00:08:14 +0900 Subject: [PATCH 55/65] fix the config setting getting and add docs --- python/private/pypi/pep508_deps.bzl | 2 +- python/private/pypi/pep508_env.bzl | 32 +++++++++++++++++++++++++++-- tests/pypi/pep508/deps_tests.bzl | 8 ++++---- 3 files changed, 35 insertions(+), 7 deletions(-) diff --git a/python/private/pypi/pep508_deps.bzl b/python/private/pypi/pep508_deps.bzl index f12477e80d..5a62cba4c1 100644 --- a/python/private/pypi/pep508_deps.bzl +++ b/python/private/pypi/pep508_deps.bzl @@ -111,7 +111,7 @@ def _platform_str(self): minor_version = self.abi[3:] if self.arch == None and self.os == None: - return "@//python/config_settings:is_python_3.{}".format(minor_version) + return str(Label("//python/config_settings:is_python_3.{}".format(minor_version))) return "cp3{}_{}_{}".format( minor_version, diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index 149ed4e507..f8c97af897 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -15,7 +15,7 @@ """This module is for implementing PEP508 environment definition. """ -# See https://stackoverflow.com/questions/45125516/possible-values-for-uname-m +# See https://stackoverflow.com/a/45125525 _platform_machine_aliases = { # These pairs mean the same hardware, but different values may be used # on different host platforms. @@ -24,13 +24,41 @@ _platform_machine_aliases = { "i386": "x86_32", "i686": "x86_32", } + +# Platform system returns results from the `uname` call. _platform_system_values = { "linux": "Linux", "osx": "Darwin", "windows": "Windows", } + +# The copy of SO [answer](https://stackoverflow.com/a/13874620) containing +# all of the platforms: +# ┍━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━━━━┑ +# │ System │ Value │ +# ┝━━━━━━━━━━━━━━━━━━━━━┿━━━━━━━━━━━━━━━━━━━━━┥ +# │ Linux │ linux or linux2 (*) │ +# │ Windows │ win32 │ +# │ Windows/Cygwin │ cygwin │ +# │ Windows/MSYS2 │ msys │ +# │ Mac OS X │ darwin │ +# │ OS/2 │ os2 │ +# │ OS/2 EMX │ os2emx │ +# │ RiscOS │ riscos │ +# │ AtheOS │ atheos │ +# │ FreeBSD 7 │ freebsd7 │ +# │ FreeBSD 8 │ freebsd8 │ +# │ FreeBSD N │ freebsdN │ +# │ OpenBSD 6 │ openbsd6 │ +# │ AIX │ aix (**) │ +# ┕━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━┙ +# +# (*) Prior to Python 3.3, the value for any Linux version is always linux2; after, it is linux. +# (**) Prior Python 3.8 could also be aix5 or aix7; use sys.platform.startswith() +# +# We are using only the subset that we actually support. _sys_platform_values = { - "linux": "posix", + "linux": "linux", "osx": "darwin", "windows": "win32", } diff --git a/tests/pypi/pep508/deps_tests.bzl b/tests/pypi/pep508/deps_tests.bzl index b6bebca629..44031ab6a5 100644 --- a/tests/pypi/pep508/deps_tests.bzl +++ b/tests/pypi/pep508/deps_tests.bzl @@ -264,9 +264,9 @@ def _test_can_get_version_select(env): env.expect.that_collection(got.deps).contains_exactly(["bar"]) env.expect.that_dict(got.deps_select).contains_exactly({ - "@//python/config_settings:is_python_3.7": ["baz"], - "@//python/config_settings:is_python_3.8": ["baz_new"], - "@//python/config_settings:is_python_3.9": ["baz_new"], + str(Label("//python/config_settings:is_python_3.7")): ["baz"], + str(Label("//python/config_settings:is_python_3.8")): ["baz_new"], + str(Label("//python/config_settings:is_python_3.9")): ["baz_new"], "@platforms//os:linux": ["baz", "posix_dep"], "cp37_linux_anyarch": ["baz", "posix_dep"], "cp37_linux_x86_64": ["arch_dep", "baz", "posix_dep"], @@ -370,7 +370,7 @@ def _test_deps_are_not_duplicated_when_encountering_platform_dep_first(env): # I am not sure why. The starlark version behaviour looks more correct. env.expect.that_collection(got.deps).contains_exactly([]) env.expect.that_dict(got.deps_select).contains_exactly({ - "@//python/config_settings:is_python_3.10": ["bar"], + str(Label("//python/config_settings:is_python_3.10")): ["bar"], "cp310_linux_aarch64": ["bar"], "cp37_linux_aarch64": ["bar"], "linux_aarch64": ["bar"], From 7348c16c0a72b23a53f0c55b93e9e53af1f5a2df Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 6 Apr 2025 00:27:30 +0900 Subject: [PATCH 56/65] move the platform to a separate file --- python/private/pypi/BUILD.bazel | 10 ++++++ python/private/pypi/evaluate_markers.bzl | 5 +-- python/private/pypi/pep508_deps.bzl | 3 +- python/private/pypi/pep508_env.bzl | 30 ++-------------- python/private/pypi/pep508_platform.bzl | 44 ++++++++++++++++++++++++ 5 files changed, 61 insertions(+), 31 deletions(-) create mode 100644 python/private/pypi/pep508_platform.bzl diff --git a/python/private/pypi/BUILD.bazel b/python/private/pypi/BUILD.bazel index 5e29956b20..e01c55d2f7 100644 --- a/python/private/pypi/BUILD.bazel +++ b/python/private/pypi/BUILD.bazel @@ -77,6 +77,7 @@ bzl_library( deps = [ ":pep508_env_bzl", ":pep508_evaluate_bzl", + ":pep508_platform_bzl", ":pep508_requirement_bzl", ], ) @@ -226,6 +227,7 @@ bzl_library( deps = [ ":pep508_env_bzl", ":pep508_evaluate_bzl", + ":pep508_platform_bzl", ":pep508_requirement_bzl", "//python/private:normalize_name_bzl", ], @@ -234,6 +236,9 @@ bzl_library( bzl_library( name = "pep508_env_bzl", srcs = ["pep508_env.bzl"], + deps = [ + ":pep508_platform_bzl", + ], ) bzl_library( @@ -245,6 +250,11 @@ bzl_library( ], ) +bzl_library( + name = "pep508_platform_bzl", + srcs = ["pep508_platform.bzl"], +) + bzl_library( name = "pep508_requirement_bzl", srcs = ["pep508_requirement.bzl"], diff --git a/python/private/pypi/evaluate_markers.bzl b/python/private/pypi/evaluate_markers.bzl index a7bd0b40cd..a0223abdc8 100644 --- a/python/private/pypi/evaluate_markers.bzl +++ b/python/private/pypi/evaluate_markers.bzl @@ -14,8 +14,9 @@ """A simple function that evaluates markers using a python interpreter.""" -load(":pep508_env.bzl", "env", _platform_from_str = "platform_from_str") +load(":pep508_env.bzl", "env") load(":pep508_evaluate.bzl", "evaluate") +load(":pep508_platform.bzl", "platform_from_str") load(":pep508_requirement.bzl", "requirement") def evaluate_markers(requirements): @@ -31,7 +32,7 @@ def evaluate_markers(requirements): for req_string, platforms in requirements.items(): req = requirement(req_string) for platform in platforms: - if evaluate(req.marker, env = env(_platform_from_str(platform, None))): + if evaluate(req.marker, env = env(platform_from_str(platform, None))): ret.setdefault(req_string, []).append(platform) return ret diff --git a/python/private/pypi/pep508_deps.bzl b/python/private/pypi/pep508_deps.bzl index 5a62cba4c1..af0a75362b 100644 --- a/python/private/pypi/pep508_deps.bzl +++ b/python/private/pypi/pep508_deps.bzl @@ -16,8 +16,9 @@ """ load("//python/private:normalize_name.bzl", "normalize_name") -load(":pep508_env.bzl", "env", "platform", "platform_from_str") +load(":pep508_env.bzl", "env") load(":pep508_evaluate.bzl", "evaluate") +load(":pep508_platform.bzl", "platform", "platform_from_str") load(":pep508_requirement.bzl", "requirement") _ALL_OS_VALUES = [ diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl index f8c97af897..265a8e9b99 100644 --- a/python/private/pypi/pep508_env.bzl +++ b/python/private/pypi/pep508_env.bzl @@ -15,6 +15,8 @@ """This module is for implementing PEP508 environment definition. """ +load(":pep508_platform.bzl", "platform_from_str") + # See https://stackoverflow.com/a/45125525 _platform_machine_aliases = { # These pairs mean the same hardware, but different values may be used @@ -116,31 +118,3 @@ def env(target_platform, *, extra = None): "platform_machine": _platform_machine_aliases, }, } - -def platform(*, abi = None, os = None, arch = None): - return struct( - abi = abi, - os = os, - arch = arch, - ) - -def platform_from_str(p, python_version): - """Return a platform from a string. - - Args: - p: {type}`str` the actual string. - python_version: {type}`str` the python version to add to platform if needed. - - Returns: - A struct that is returned by the `_platform` function. - """ - if p.startswith("cp"): - abi, _, p = p.partition("_") - elif python_version: - major, _, tail = python_version.partition(".") - abi = "cp{}{}".format(major, tail) - else: - abi = None - - os, _, arch = p.partition("_") - return platform(abi = abi, os = os or None, arch = arch or None) diff --git a/python/private/pypi/pep508_platform.bzl b/python/private/pypi/pep508_platform.bzl new file mode 100644 index 0000000000..7403d8a65b --- /dev/null +++ b/python/private/pypi/pep508_platform.bzl @@ -0,0 +1,44 @@ +# Copyright 2025 The Bazel Authors. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""The platform abstraction +""" + +def platform(*, abi = None, os = None, arch = None): + return struct( + abi = abi, + os = os, + arch = arch, + ) + +def platform_from_str(p, python_version): + """Return a platform from a string. + + Args: + p: {type}`str` the actual string. + python_version: {type}`str` the python version to add to platform if needed. + + Returns: + A struct that is returned by the `_platform` function. + """ + if p.startswith("cp"): + abi, _, p = p.partition("_") + elif python_version: + major, _, tail = python_version.partition(".") + abi = "cp{}{}".format(major, tail) + else: + abi = None + + os, _, arch = p.partition("_") + return platform(abi = abi, os = os or None, arch = arch or None) From c4b08add37d8fd1b00e0c23a64c15e76727f2b9d Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 6 Apr 2025 00:34:50 +0900 Subject: [PATCH 57/65] add docs and a note --- python/private/pypi/pep508_platform.bzl | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/python/private/pypi/pep508_platform.bzl b/python/private/pypi/pep508_platform.bzl index 7403d8a65b..381a8d7a08 100644 --- a/python/private/pypi/pep508_platform.bzl +++ b/python/private/pypi/pep508_platform.bzl @@ -16,6 +16,19 @@ """ def platform(*, abi = None, os = None, arch = None): + """platform returns a struct for the platform. + + Args: + abi: {type}`str | None` the target ABI, e.g. `"cp39"`. + os: {type}`str | None` the target os, e.g. `"linux"`. + arch: {type}`str | None` the target CPU, e.g. `"aarch64"`. + + Returns: + A struct. + """ + + # Note, this is used a lot as a key in dictionaries, so it cannot contain + # methods. return struct( abi = abi, os = os, From ab470954ba4c18554050138b8f3d3bbe7105298f Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Wed, 9 Apr 2025 22:14:47 +0900 Subject: [PATCH 58/65] move the requirement line parsing to starlark --- python/private/pypi/whl_installer/wheel_installer.py | 7 ------- python/private/pypi/whl_library.bzl | 3 ++- 2 files changed, 2 insertions(+), 8 deletions(-) diff --git a/python/private/pypi/whl_installer/wheel_installer.py b/python/private/pypi/whl_installer/wheel_installer.py index 3ccd9bad60..73994c65f8 100644 --- a/python/private/pypi/whl_installer/wheel_installer.py +++ b/python/private/pypi/whl_installer/wheel_installer.py @@ -103,7 +103,6 @@ def _setup_namespace_pkg_compatibility(wheel_dir: str) -> None: def _extract_wheel( wheel_file: str, - extras: Dict[str, Set[str]], enable_implicit_namespace_pkgs: bool, installation_dir: Path = Path("."), ) -> None: @@ -112,7 +111,6 @@ def _extract_wheel( Args: wheel_file: the filepath of the .whl installation_dir: the destination directory for installation of the wheel. - extras: a list of extras to add as dependencies for the installed wheel enable_implicit_namespace_pkgs: if true, disables conversion of implicit namespace packages and will unzip as-is """ @@ -122,13 +120,11 @@ def _extract_wheel( if not enable_implicit_namespace_pkgs: _setup_namespace_pkg_compatibility(installation_dir) - extras_requested = extras[whl.name] if whl.name in extras else set() requires_dist = whl.metadata.get_all("Requires-Dist", []) abi = f"cp{sys.version_info.major}{sys.version_info.minor}" metadata = { "name": whl.name, "version": whl.version, - "extras": list(extras_requested), "python_version": sys.version.partition(" ")[0], "requires_dist": requires_dist, "abi": abi, @@ -157,11 +153,8 @@ def main() -> None: if args.whl_file: whl = Path(args.whl_file) - name, extras_for_pkg = _parse_requirement_for_extra(args.requirement) - extras = {name: extras_for_pkg} if extras_for_pkg and name else dict() _extract_wheel( wheel_file=whl, - extras=extras, enable_implicit_namespace_pkgs=args.enable_implicit_namespace_pkgs, ) return diff --git a/python/private/pypi/whl_library.bzl b/python/private/pypi/whl_library.bzl index 1414710539..d76bf66b60 100644 --- a/python/private/pypi/whl_library.bzl +++ b/python/private/pypi/whl_library.bzl @@ -25,6 +25,7 @@ load(":parse_requirements.bzl", "host_platform") load(":parse_whl_name.bzl", "parse_whl_name") load(":patch_whl.bzl", "patch_whl") load(":pep508_deps.bzl", "deps") +load(":pep508_requirement.bzl", "requirement") load(":pypi_repo_utils.bzl", "pypi_repo_utils") load(":whl_target_platforms.bzl", "whl_target_platforms") @@ -430,7 +431,7 @@ def _whl_library_impl(rctx): platforms = target_platforms or [ "{}_{}".format(metadata["abi"], host_platform(rctx)), ], - extras = metadata["extras"], + extras = requirement(rctx.attr.requirement).extras, host_python_version = metadata["python_version"], ) From f834f40912b67440e9b2578acec5ab8eecbdc359 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Wed, 9 Apr 2025 22:59:03 +0900 Subject: [PATCH 59/65] move METADATA reading to starlark and add extra tests for the requirement spec parsing --- python/private/pypi/pep508_requirement.bzl | 9 ++- .../pypi/whl_installer/wheel_installer.py | 7 -- python/private/pypi/whl_library.bzl | 80 ++++++++++++++++--- tests/pypi/pep508/BUILD.bazel | 5 ++ tests/pypi/pep508/requirement_tests.bzl | 58 ++++++++++++++ .../whl_installer/wheel_installer_test.py | 38 --------- 6 files changed, 136 insertions(+), 61 deletions(-) create mode 100644 tests/pypi/pep508/requirement_tests.bzl diff --git a/python/private/pypi/pep508_requirement.bzl b/python/private/pypi/pep508_requirement.bzl index 618ffaf17a..11f2b3e8fa 100644 --- a/python/private/pypi/pep508_requirement.bzl +++ b/python/private/pypi/pep508_requirement.bzl @@ -17,7 +17,7 @@ load("//python/private:normalize_name.bzl", "normalize_name") -_STRIP = ["(", " ", ">", "=", "<", "~", "!"] +_STRIP = ["(", " ", ">", "=", "<", "~", "!", "@"] def requirement(spec): """Parse a PEP508 requirement line @@ -28,15 +28,18 @@ def requirement(spec): Returns: A struct with the information. """ + spec = spec.strip() requires, _, maybe_hashes = spec.partition(";") marker, _, _ = maybe_hashes.partition("--hash") requires, _, extras_unparsed = requires.partition("[") + extras_unparsed, _, _ = extras_unparsed.partition("]") for char in _STRIP: requires, _, _ = requires.partition(char) - extras = extras_unparsed.strip("]").split(",") + extras = extras_unparsed.replace(" ", "").split(",") + name = requires.strip(" ") return struct( - name = normalize_name(requires.strip(" ")), + name = normalize_name(name).replace("_", "-"), marker = marker.strip(" "), extras = extras, ) diff --git a/python/private/pypi/whl_installer/wheel_installer.py b/python/private/pypi/whl_installer/wheel_installer.py index 73994c65f8..c7695d92e8 100644 --- a/python/private/pypi/whl_installer/wheel_installer.py +++ b/python/private/pypi/whl_installer/wheel_installer.py @@ -120,14 +120,8 @@ def _extract_wheel( if not enable_implicit_namespace_pkgs: _setup_namespace_pkg_compatibility(installation_dir) - requires_dist = whl.metadata.get_all("Requires-Dist", []) - abi = f"cp{sys.version_info.major}{sys.version_info.minor}" metadata = { - "name": whl.name, - "version": whl.version, "python_version": sys.version.partition(" ")[0], - "requires_dist": requires_dist, - "abi": abi, "entry_points": [ { "name": name, @@ -137,7 +131,6 @@ def _extract_wheel( for name, (module, attribute) in sorted(whl.entry_points().items()) ], } - print(metadata) with open(os.path.join(installation_dir, "metadata.json"), "w") as f: json.dump(metadata, f) diff --git a/python/private/pypi/whl_library.bzl b/python/private/pypi/whl_library.bzl index d76bf66b60..73d61af4a7 100644 --- a/python/private/pypi/whl_library.bzl +++ b/python/private/pypi/whl_library.bzl @@ -228,6 +228,61 @@ def _create_repository_execution_environment(rctx, python_interpreter, logger = env[_CPPFLAGS] = " ".join(cppflags) return env +def _read_and_parse_required_metadata(rctx, logger): + contents = [] + for entry in rctx.path("site-packages").readdir(): + if not entry.basename.endswith(".dist-info"): + continue + + if not entry.is_dir: + continue + + metadata_file = entry.get_child("METADATA") + + if not metadata_file.exists: + logger.fail("The METADATA file for the wheel could not be found") + return None + + contents.extend(rctx.read(metadata_file).split("\n")) + break + + single_value_fields = { + "License: ": "license", + "Name: ": "name", + "Version: ": "version", + } + requires_dist = "Requires-Dist: " + parsed = {} + for line in contents: + if not line or line.startswith("Dynamic"): + # Stop parsing on first empty line + break + + found_prefix = None + for prefix in single_value_fields: + if line.startswith(prefix): + found_prefix = prefix + break + + if found_prefix: + key = single_value_fields.pop(found_prefix) + _, _, value = line.partition(found_prefix) + parsed[key] = value.strip() + continue + + if not line.startswith(requires_dist): + continue + + _, _, value = line.partition(requires_dist) + parsed.setdefault("requires_dist", []).append(value.strip(" ")) + + return struct( + name = parsed["name"], + version = parsed["version"], + license = parsed.get("license"), + requires_dist = parsed.get("requires_dist", []), + ) + def _whl_library_impl(rctx): logger = repo_utils.logger(rctx) python_interpreter = pypi_repo_utils.resolve_python_interpreter( @@ -400,7 +455,7 @@ def _whl_library_impl(rctx): # # This means that whl_library_targets will have to accept the following args: # * name - the name of the package in the METADATA. - # * requires_dist - the list of METADATA RequiresDist. + # * requires_dist - the list of METADATA Requires-Dist. # * platforms - the list of target platforms. The target_platforms # should come from the hub repo via a 'load' statement so that they don't # need to be passed as an argument to `whl_library`. @@ -419,20 +474,19 @@ def _whl_library_impl(rctx): # * group_name, group_deps - this info can stay in the hub repository so that # it is piped at the analysis time and changing the requirement groups does # cause to re-fetch the deps. + whl_metadata = _read_and_parse_required_metadata(rctx, logger) + python_version = metadata["python_version"] + + # TODO @aignas 2025-04-09: this will later be removed when loaded through the hub + major_minor, _, _ = python_version.rpartition(".") package_deps = deps( - # TODO @aignas 2025-04-04: get the following from manually parsing - # METADATA to avoid Python dependency: - # * name of the package - # * version of the package - # * RequiresDist - # * ProvidesExtras - name = metadata["name"], - requires_dist = metadata["requires_dist"], + name = whl_metadata.name, + requires_dist = whl_metadata.requires_dist, platforms = target_platforms or [ - "{}_{}".format(metadata["abi"], host_platform(rctx)), + "cp{}_{}".format(major_minor.replace(".", ""), host_platform(rctx)), ], extras = requirement(rctx.attr.requirement).extras, - host_python_version = metadata["python_version"], + host_python_version = python_version, ) build_file_contents = generate_whl_library_build_bazel( @@ -444,8 +498,8 @@ def _whl_library_impl(rctx): group_deps = rctx.attr.group_deps, data_exclude = rctx.attr.pip_data_exclude, tags = [ - "pypi_name=" + metadata["name"], - "pypi_version=" + metadata["version"], + "pypi_name=" + whl_metadata.name, + "pypi_version=" + whl_metadata.version, ], entry_points = entry_points, annotation = None if not rctx.attr.annotation else struct(**json.decode(rctx.read(rctx.attr.annotation))), diff --git a/tests/pypi/pep508/BUILD.bazel b/tests/pypi/pep508/BUILD.bazel index 7c6e13aec3..2306265b7b 100644 --- a/tests/pypi/pep508/BUILD.bazel +++ b/tests/pypi/pep508/BUILD.bazel @@ -1,5 +1,6 @@ load(":deps_tests.bzl", "deps_test_suite") load(":evaluate_tests.bzl", "evaluate_test_suite") +load(":requirement_tests.bzl", "requirement_test_suite") evaluate_test_suite( name = "evaluate_tests", @@ -8,3 +9,7 @@ evaluate_test_suite( deps_test_suite( name = "deps_tests", ) + +requirement_test_suite( + name = "requirement_tests", +) diff --git a/tests/pypi/pep508/requirement_tests.bzl b/tests/pypi/pep508/requirement_tests.bzl new file mode 100644 index 0000000000..0658df0a0c --- /dev/null +++ b/tests/pypi/pep508/requirement_tests.bzl @@ -0,0 +1,58 @@ +# Copyright 2025 The Bazel Authors. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Tests for parsing the requirement specifier.""" + +load("@rules_testing//lib:test_suite.bzl", "test_suite") +load("//python/private/pypi:pep508_requirement.bzl", "requirement") # buildifier: disable=bzl-visibility + +_tests = [] + +def _test_all(env): + cases = [ + ("name[foo]", ("name", ["foo"])), + ("name[ Foo123 ]", ("name", ["Foo123"])), + (" name1[ foo ] ", ("name1", ["foo"])), + ("Name[foo]", ("name", ["foo"])), + ("name_foo[bar]", ("name-foo", ["bar"])), + ( + "name [fred,bar] @ http://foo.com ; python_version=='2.7'", + ("name", ["fred", "bar"]), + ), + ( + "name[quux, strange];python_version<'2.7' and platform_version=='2'", + ("name", ["quux", "strange"]), + ), + ( + "name; (os_name=='a' or os_name=='b') and os_name=='c'", + ("name", None), + ), + ( + "name@http://foo.com", + ("name", None), + ), + ] + + for case, expected in cases: + got = requirement(case) + env.expect.that_str(got.name).equals(expected[0]) + if expected[1] != None: + env.expect.that_collection(got.extras).contains_exactly(expected[1]) + +_tests.append(_test_all) + +def requirement_test_suite(name): # buildifier: disable=function-docstring + test_suite( + name = name, + basic_tests = _tests, + ) diff --git a/tests/pypi/whl_installer/wheel_installer_test.py b/tests/pypi/whl_installer/wheel_installer_test.py index 690c408981..5e7a8eeb30 100644 --- a/tests/pypi/whl_installer/wheel_installer_test.py +++ b/tests/pypi/whl_installer/wheel_installer_test.py @@ -22,39 +22,6 @@ from python.private.pypi.whl_installer import wheel_installer -class TestRequirementExtrasParsing(unittest.TestCase): - def test_parses_requirement_for_extra(self) -> None: - cases = [ - ("name[foo]", ("name", frozenset(["foo"]))), - ("name[ Foo123 ]", ("name", frozenset(["Foo123"]))), - (" name1[ foo ] ", ("name1", frozenset(["foo"]))), - ("Name[foo]", ("name", frozenset(["foo"]))), - ("name_foo[bar]", ("name-foo", frozenset(["bar"]))), - ( - "name [fred,bar] @ http://foo.com ; python_version=='2.7'", - ("name", frozenset(["fred", "bar"])), - ), - ( - "name[quux, strange];python_version<'2.7' and platform_version=='2'", - ("name", frozenset(["quux", "strange"])), - ), - ( - "name; (os_name=='a' or os_name=='b') and os_name=='c'", - (None, None), - ), - ( - "name@http://foo.com", - (None, None), - ), - ] - - for case, expected in cases: - with self.subTest(): - self.assertTupleEqual( - wheel_installer._parse_requirement_for_extra(case), expected - ) - - class TestWhlFilegroup(unittest.TestCase): def setUp(self) -> None: self.wheel_name = "example_minimal_package-0.0.1-py3-none-any.whl" @@ -91,13 +58,8 @@ def test_wheel_exists(self) -> None: metadata_file_content = json.load(metadata_file) want = dict( - abi="cp311", - version="0.0.1", - name="example-minimal-package", entry_points=[], - extras=[], python_version="3.11.11", - requires_dist=[], ) self.assertEqual(want, metadata_file_content) From 3c6532d4b977e1d7a03cac97db38373c08783019 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Wed, 9 Apr 2025 23:05:48 +0900 Subject: [PATCH 60/65] fixup tests --- tests/pypi/whl_installer/wheel_installer_test.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/tests/pypi/whl_installer/wheel_installer_test.py b/tests/pypi/whl_installer/wheel_installer_test.py index 5e7a8eeb30..3c118af3c4 100644 --- a/tests/pypi/whl_installer/wheel_installer_test.py +++ b/tests/pypi/whl_installer/wheel_installer_test.py @@ -35,9 +35,8 @@ def tearDown(self): def test_wheel_exists(self) -> None: wheel_installer._extract_wheel( Path(self.wheel_path), - installation_dir=Path(self.wheel_dir), - extras={}, enable_implicit_namespace_pkgs=False, + installation_dir=Path(self.wheel_dir), ) want_files = [ From ba81df2574f7a7b4ffed22cca213939ef59d71bc Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sat, 12 Apr 2025 09:01:19 +0900 Subject: [PATCH 61/65] move the METADATA reading into a separate file --- python/private/pypi/BUILD.bazel | 6 ++ python/private/pypi/whl_library.bzl | 70 +++--------------- python/private/pypi/whl_metadata.bzl | 102 +++++++++++++++++++++++++++ 3 files changed, 118 insertions(+), 60 deletions(-) create mode 100644 python/private/pypi/whl_metadata.bzl diff --git a/python/private/pypi/BUILD.bazel b/python/private/pypi/BUILD.bazel index e01c55d2f7..7297238cb4 100644 --- a/python/private/pypi/BUILD.bazel +++ b/python/private/pypi/BUILD.bazel @@ -382,6 +382,7 @@ bzl_library( ":patch_whl_bzl", ":pep508_deps_bzl", ":pypi_repo_utils_bzl", + ":whl_metadata_bzl", ":whl_target_platforms_bzl", "//python/private:auth_bzl", "//python/private:envsubst_bzl", @@ -390,6 +391,11 @@ bzl_library( ], ) +bzl_library( + name = "whl_metadata_bzl", + srcs = ["whl_metadata.bzl"], +) + bzl_library( name = "whl_repo_name_bzl", srcs = ["whl_repo_name.bzl"], diff --git a/python/private/pypi/whl_library.bzl b/python/private/pypi/whl_library.bzl index 9c1a2646b3..54f9ff3909 100644 --- a/python/private/pypi/whl_library.bzl +++ b/python/private/pypi/whl_library.bzl @@ -27,6 +27,7 @@ load(":patch_whl.bzl", "patch_whl") load(":pep508_deps.bzl", "deps") load(":pep508_requirement.bzl", "requirement") load(":pypi_repo_utils.bzl", "pypi_repo_utils") +load(":whl_metadata.bzl", "whl_metadata") load(":whl_target_platforms.bzl", "whl_target_platforms") _CPPFLAGS = "CPPFLAGS" @@ -232,61 +233,6 @@ def _create_repository_execution_environment(rctx, python_interpreter, logger = env[_CPPFLAGS] = " ".join(cppflags) return env -def _read_and_parse_required_metadata(rctx, logger): - contents = [] - for entry in rctx.path("site-packages").readdir(): - if not entry.basename.endswith(".dist-info"): - continue - - if not entry.is_dir: - continue - - metadata_file = entry.get_child("METADATA") - - if not metadata_file.exists: - logger.fail("The METADATA file for the wheel could not be found") - return None - - contents.extend(rctx.read(metadata_file).split("\n")) - break - - single_value_fields = { - "License: ": "license", - "Name: ": "name", - "Version: ": "version", - } - requires_dist = "Requires-Dist: " - parsed = {} - for line in contents: - if not line or line.startswith("Dynamic"): - # Stop parsing on first empty line - break - - found_prefix = None - for prefix in single_value_fields: - if line.startswith(prefix): - found_prefix = prefix - break - - if found_prefix: - key = single_value_fields.pop(found_prefix) - _, _, value = line.partition(found_prefix) - parsed[key] = value.strip() - continue - - if not line.startswith(requires_dist): - continue - - _, _, value = line.partition(requires_dist) - parsed.setdefault("requires_dist", []).append(value.strip(" ")) - - return struct( - name = parsed["name"], - version = parsed["version"], - license = parsed.get("license"), - requires_dist = parsed.get("requires_dist", []), - ) - def _whl_library_impl(rctx): logger = repo_utils.logger(rctx) python_interpreter = pypi_repo_utils.resolve_python_interpreter( @@ -478,14 +424,18 @@ def _whl_library_impl(rctx): # * group_name, group_deps - this info can stay in the hub repository so that # it is piped at the analysis time and changing the requirement groups does # cause to re-fetch the deps. - whl_metadata = _read_and_parse_required_metadata(rctx, logger) python_version = metadata["python_version"] + metadata = whl_metadata( + install_dir = rctx.path("site-packages"), + read_fn = rctx.read, + logger = logger, + ) # TODO @aignas 2025-04-09: this will later be removed when loaded through the hub major_minor, _, _ = python_version.rpartition(".") package_deps = deps( - name = whl_metadata.name, - requires_dist = whl_metadata.requires_dist, + name = metadata.name, + requires_dist = metadata.requires_dist, platforms = target_platforms or [ "cp{}_{}".format(major_minor.replace(".", ""), host_platform(rctx)), ], @@ -502,8 +452,8 @@ def _whl_library_impl(rctx): group_deps = rctx.attr.group_deps, data_exclude = rctx.attr.pip_data_exclude, tags = [ - "pypi_name=" + whl_metadata.name, - "pypi_version=" + whl_metadata.version, + "pypi_name=" + metadata.name, + "pypi_version=" + metadata.version, ], entry_points = entry_points, annotation = None if not rctx.attr.annotation else struct(**json.decode(rctx.read(rctx.attr.annotation))), diff --git a/python/private/pypi/whl_metadata.bzl b/python/private/pypi/whl_metadata.bzl new file mode 100644 index 0000000000..1fc5ac4d95 --- /dev/null +++ b/python/private/pypi/whl_metadata.bzl @@ -0,0 +1,102 @@ +"""A simple function to find the METADATA file and parse it""" + +_NAME = "Name: " +_PROVIDES_EXTRA = "Provides-Extra: " +_REQUIRES_DIST = "Requires-Dist: " +_VERSION = "Version: " + +def whl_metadata(*, install_dir, read_fn, logger): + """Find and parse the METADATA file in the extracted whl contents dir. + + Args: + install_dir: {type}`path` location where the wheel has been extracted. + read_fn: the function used to read files. + logger: the function used to log failures. + + Returns: + A struct with parsed values: + * `name`: {type}`str` the name of the wheel. + * `version`: {type}`str` the version of the wheel. + * `requires_dist`: {type}`list[str]` the list of requirements. + * `provides_extra`: {type}`list[str]` the list of extras that this package + provides. + """ + metadata_file = find_whl_metadata(install_dir = install_dir, logger = logger) + return parse_whl_metadata(read_fn(metadata_file)) + +def parse_whl_metadata(contents): + """Parse .whl METADATA file + + Args: + contents: {type}`str` the contents of the file. + + Returns: + A struct with parsed values: + * `name`: {type}`str` the name of the wheel. + * `version`: {type}`str` the version of the wheel. + * `requires_dist`: {type}`list[str]` the list of requirements. + * `provides_extra`: {type}`list[str]` the list of extras that this package + provides. + """ + single_value_fields = { + _NAME: "name", + _VERSION: "version", + } + parsed = {} + for line in contents.strip().split("\n"): + if not line.strip(): + # Stop parsing on first empty line, which marks the end of the + # headers containing the metadata. + break + + found_prefix = None + for prefix in single_value_fields: + if line.startswith(prefix): + found_prefix = prefix + break + + if found_prefix: + key = single_value_fields.pop(found_prefix) + _, _, value = line.partition(found_prefix) + parsed[key] = value.strip() + continue + + if line.startswith(_REQUIRES_DIST): + _, _, value = line.partition(_REQUIRES_DIST) + parsed.setdefault("requires_dist", []).append(value.strip(" ")) + elif line.startswith(_PROVIDES_EXTRA): + _, _, value = line.partition(_PROVIDES_EXTRA) + parsed.setdefault("provides_extra", []).append(value.strip(" ")) + + return struct( + name = parsed["name"], + version = parsed["version"], + license = parsed.get("license"), + requires_dist = parsed.get("requires_dist", []), + provides_extra = parsed.get("provides_extra", []), + ) + +def find_whl_metadata(*, install_dir, logger): + """Find the whl METADATA file in the install_dir. + + Args: + install_dir: {type}`path` location where the wheel has been extracted. + logger: the function used to log failures. + + Returns: + {type}`path` The path to the METADATA file. + """ + for maybe_dist_info in install_dir.readdir(): + # first find the ".dist-info" folder + if not (maybe_dist_info.is_dir and maybe_dist_info.basename.endswith(".dist-info")): + continue + + metadata_file = maybe_dist_info.get_child("METADATA") + + if metadata_file.exists: + return metadata_file + + break + + logger.fail("The METADATA file for the wheel could not be found") + return None From f9be3f73f0b974098ff86330a89e4a9829e28ee6 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 13 Apr 2025 11:55:15 +0900 Subject: [PATCH 62/65] first test --- python/private/pypi/whl_metadata.bzl | 2 +- tests/pypi/whl_metadata/BUILD.bazel | 5 ++++ .../pypi/whl_metadata/whl_metadata_tests.bzl | 30 +++++++++++++++++++ 3 files changed, 36 insertions(+), 1 deletion(-) create mode 100644 tests/pypi/whl_metadata/BUILD.bazel create mode 100644 tests/pypi/whl_metadata/whl_metadata_tests.bzl diff --git a/python/private/pypi/whl_metadata.bzl b/python/private/pypi/whl_metadata.bzl index 1fc5ac4d95..7a21d43709 100644 --- a/python/private/pypi/whl_metadata.bzl +++ b/python/private/pypi/whl_metadata.bzl @@ -98,5 +98,5 @@ def find_whl_metadata(*, install_dir, logger): break - logger.fail("The METADATA file for the wheel could not be found") + logger.fail("The METADATA file for the wheel could not be found in '{}'".format(install_dir.basename)) return None diff --git a/tests/pypi/whl_metadata/BUILD.bazel b/tests/pypi/whl_metadata/BUILD.bazel new file mode 100644 index 0000000000..3f1d665dd2 --- /dev/null +++ b/tests/pypi/whl_metadata/BUILD.bazel @@ -0,0 +1,5 @@ +load(":whl_metadata_tests.bzl", "whl_metadata_test_suite") + +whl_metadata_test_suite( + name = "whl_metadata_tests", +) diff --git a/tests/pypi/whl_metadata/whl_metadata_tests.bzl b/tests/pypi/whl_metadata/whl_metadata_tests.bzl new file mode 100644 index 0000000000..85d4fdbf91 --- /dev/null +++ b/tests/pypi/whl_metadata/whl_metadata_tests.bzl @@ -0,0 +1,30 @@ +"" + +load("@rules_testing//lib:test_suite.bzl", "test_suite") +load( + "//python/private/pypi:whl_metadata.bzl", + "find_whl_metadata", +) # buildifier: disable=bzl-visibility + +_tests = [] + +def _test_empty(env): + fake_path = struct( + basename = "site-packages", + readdir = lambda: [], + ) + fail_messages = [] + find_whl_metadata(install_dir = fake_path, logger = struct( + fail = fail_messages.append, + )) + env.expect.that_collection(fail_messages).contains_exactly([ + "The METADATA file for the wheel could not be found in 'site-packages'", + ]) + +_tests.append(_test_empty) + +def whl_metadata_test_suite(name): # buildifier: disable=function-docstring + test_suite( + name = name, + basic_tests = _tests, + ) From 75e72d528bd8f8914447b8cd9acca3430670d18d Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 13 Apr 2025 12:02:41 +0900 Subject: [PATCH 63/65] second test and better error message --- python/private/pypi/whl_metadata.bzl | 9 ++++-- .../pypi/whl_metadata/whl_metadata_tests.bzl | 28 +++++++++++++++++-- 2 files changed, 33 insertions(+), 4 deletions(-) diff --git a/python/private/pypi/whl_metadata.bzl b/python/private/pypi/whl_metadata.bzl index 7a21d43709..8e9799c76e 100644 --- a/python/private/pypi/whl_metadata.bzl +++ b/python/private/pypi/whl_metadata.bzl @@ -86,17 +86,22 @@ def find_whl_metadata(*, install_dir, logger): Returns: {type}`path` The path to the METADATA file. """ + dist_info = None for maybe_dist_info in install_dir.readdir(): # first find the ".dist-info" folder if not (maybe_dist_info.is_dir and maybe_dist_info.basename.endswith(".dist-info")): continue - metadata_file = maybe_dist_info.get_child("METADATA") + dist_info = maybe_dist_info + metadata_file = dist_info.get_child("METADATA") if metadata_file.exists: return metadata_file break - logger.fail("The METADATA file for the wheel could not be found in '{}'".format(install_dir.basename)) + if dist_info: + logger.fail("The METADATA file for the wheel could not be found in '{}/{}'".format(install_dir.basename, dist_info.basename)) + else: + logger.fail("The '*.dist-info' directory could not be found in '{}'".format(install_dir.basename)) return None diff --git a/tests/pypi/whl_metadata/whl_metadata_tests.bzl b/tests/pypi/whl_metadata/whl_metadata_tests.bzl index 85d4fdbf91..f52c4ed3bc 100644 --- a/tests/pypi/whl_metadata/whl_metadata_tests.bzl +++ b/tests/pypi/whl_metadata/whl_metadata_tests.bzl @@ -11,18 +11,42 @@ _tests = [] def _test_empty(env): fake_path = struct( basename = "site-packages", - readdir = lambda: [], + readdir = lambda watch = None: [], ) fail_messages = [] find_whl_metadata(install_dir = fake_path, logger = struct( fail = fail_messages.append, )) env.expect.that_collection(fail_messages).contains_exactly([ - "The METADATA file for the wheel could not be found in 'site-packages'", + "The '*.dist-info' directory could not be found in 'site-packages'", ]) _tests.append(_test_empty) +def _test_contains_dist_info_but_no_metadata(env): + fake_path = struct( + basename = "site-packages", + readdir = lambda watch = None: [ + struct( + basename = "something.dist-info", + is_dir = True, + get_child = lambda basename: struct( + basename = basename, + exists = False, + ), + ), + ], + ) + fail_messages = [] + find_whl_metadata(install_dir = fake_path, logger = struct( + fail = fail_messages.append, + )) + env.expect.that_collection(fail_messages).contains_exactly([ + "The METADATA file for the wheel could not be found in 'site-packages/something.dist-info'", + ]) + +_tests.append(_test_contains_dist_info_but_no_metadata) + def whl_metadata_test_suite(name): # buildifier: disable=function-docstring test_suite( name = name, From 7b7419313c984aada839adeac6f9c6214b8d914b Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 13 Apr 2025 12:05:29 +0900 Subject: [PATCH 64/65] add a test which checks that we are seraching for METADATA. --- .../pypi/whl_metadata/whl_metadata_tests.bzl | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/tests/pypi/whl_metadata/whl_metadata_tests.bzl b/tests/pypi/whl_metadata/whl_metadata_tests.bzl index f52c4ed3bc..03a64351cd 100644 --- a/tests/pypi/whl_metadata/whl_metadata_tests.bzl +++ b/tests/pypi/whl_metadata/whl_metadata_tests.bzl @@ -47,6 +47,29 @@ def _test_contains_dist_info_but_no_metadata(env): _tests.append(_test_contains_dist_info_but_no_metadata) +def _test_contains_metadata(env): + fake_path = struct( + basename = "site-packages", + readdir = lambda watch = None: [ + struct( + basename = "something.dist-info", + is_dir = True, + get_child = lambda basename: struct( + basename = basename, + exists = True, + ), + ), + ], + ) + fail_messages = [] + got = find_whl_metadata(install_dir = fake_path, logger = struct( + fail = fail_messages.append, + )) + env.expect.that_collection(fail_messages).contains_exactly([]) + env.expect.that_str(got.basename).equals("METADATA") + +_tests.append(_test_contains_metadata) + def whl_metadata_test_suite(name): # buildifier: disable=function-docstring test_suite( name = name, From 2367c252a232e8a9f86e92f7d3fce5085c08f107 Mon Sep 17 00:00:00 2001 From: Ignas Anikevicius <240938+aignas@users.noreply.github.com> Date: Sun, 13 Apr 2025 18:11:34 +0900 Subject: [PATCH 65/65] finish tests --- python/private/pypi/whl_metadata.bzl | 47 +++++++------ .../pypi/whl_metadata/whl_metadata_tests.bzl | 70 +++++++++++++++++++ 2 files changed, 94 insertions(+), 23 deletions(-) diff --git a/python/private/pypi/whl_metadata.bzl b/python/private/pypi/whl_metadata.bzl index 8e9799c76e..8a86ffbff1 100644 --- a/python/private/pypi/whl_metadata.bzl +++ b/python/private/pypi/whl_metadata.bzl @@ -22,7 +22,14 @@ def whl_metadata(*, install_dir, read_fn, logger): provides. """ metadata_file = find_whl_metadata(install_dir = install_dir, logger = logger) - return parse_whl_metadata(read_fn(metadata_file)) + contents = read_fn(metadata_file) + result = parse_whl_metadata(contents) + + if not (result.name and result.version): + logger.fail("Failed to parsed the wheel METADATA file:\n{}".format(contents)) + return None + + return result def parse_whl_metadata(contents): """Parse .whl METADATA file @@ -38,42 +45,36 @@ def parse_whl_metadata(contents): * `provides_extra`: {type}`list[str]` the list of extras that this package provides. """ - single_value_fields = { - _NAME: "name", - _VERSION: "version", + parsed = { + "name": "", + "provides_extra": [], + "requires_dist": [], + "version": "", } - parsed = {} for line in contents.strip().split("\n"): if not line.strip(): # Stop parsing on first empty line, which marks the end of the # headers containing the metadata. break - found_prefix = None - for prefix in single_value_fields: - if line.startswith(prefix): - found_prefix = prefix - break - - if found_prefix: - key = single_value_fields.pop(found_prefix) - _, _, value = line.partition(found_prefix) - parsed[key] = value.strip() - continue - - if line.startswith(_REQUIRES_DIST): + if line.startswith(_NAME): + _, _, value = line.partition(_NAME) + parsed["name"] = value.strip() + elif line.startswith(_VERSION): + _, _, value = line.partition(_VERSION) + parsed["version"] = value.strip() + elif line.startswith(_REQUIRES_DIST): _, _, value = line.partition(_REQUIRES_DIST) - parsed.setdefault("requires_dist", []).append(value.strip(" ")) + parsed["requires_dist"].append(value.strip(" ")) elif line.startswith(_PROVIDES_EXTRA): _, _, value = line.partition(_PROVIDES_EXTRA) - parsed.setdefault("provides_extra", []).append(value.strip(" ")) + parsed["provides_extra"].append(value.strip(" ")) return struct( name = parsed["name"], + provides_extra = parsed["provides_extra"], + requires_dist = parsed["requires_dist"], version = parsed["version"], - license = parsed.get("license"), - requires_dist = parsed.get("requires_dist", []), - provides_extra = parsed.get("provides_extra", []), ) def find_whl_metadata(*, install_dir, logger): diff --git a/tests/pypi/whl_metadata/whl_metadata_tests.bzl b/tests/pypi/whl_metadata/whl_metadata_tests.bzl index 03a64351cd..4acbc9213d 100644 --- a/tests/pypi/whl_metadata/whl_metadata_tests.bzl +++ b/tests/pypi/whl_metadata/whl_metadata_tests.bzl @@ -1,9 +1,11 @@ "" load("@rules_testing//lib:test_suite.bzl", "test_suite") +load("@rules_testing//lib:truth.bzl", "subjects") load( "//python/private/pypi:whl_metadata.bzl", "find_whl_metadata", + "parse_whl_metadata", ) # buildifier: disable=bzl-visibility _tests = [] @@ -70,6 +72,74 @@ def _test_contains_metadata(env): _tests.append(_test_contains_metadata) +def _parse_whl_metadata(env, **kwargs): + result = parse_whl_metadata(**kwargs) + + return env.expect.that_struct( + struct( + name = result.name, + version = result.version, + requires_dist = result.requires_dist, + provides_extra = result.provides_extra, + ), + attrs = dict( + name = subjects.str, + version = subjects.str, + requires_dist = subjects.collection, + provides_extra = subjects.collection, + ), + ) + +def _test_parse_metadata_invalid(env): + got = _parse_whl_metadata( + env, + contents = "", + ) + got.name().equals("") + got.version().equals("") + got.requires_dist().contains_exactly([]) + got.provides_extra().contains_exactly([]) + +_tests.append(_test_parse_metadata_invalid) + +def _test_parse_metadata_basic(env): + got = _parse_whl_metadata( + env, + contents = """\ +Name: foo +Version: 0.0.1 +""", + ) + got.name().equals("foo") + got.version().equals("0.0.1") + got.requires_dist().contains_exactly([]) + got.provides_extra().contains_exactly([]) + +_tests.append(_test_parse_metadata_basic) + +def _test_parse_metadata_all(env): + got = _parse_whl_metadata( + env, + contents = """\ +Name: foo +Version: 0.0.1 +Requires-Dist: bar; extra == "all" +Provides-Extra: all + +Requires-Dist: this will be ignored +""", + ) + got.name().equals("foo") + got.version().equals("0.0.1") + got.requires_dist().contains_exactly([ + "bar; extra == \"all\"", + ]) + got.provides_extra().contains_exactly([ + "all", + ]) + +_tests.append(_test_parse_metadata_all) + def whl_metadata_test_suite(name): # buildifier: disable=function-docstring test_suite( name = name,