refactor

Author: aignas

python/private/pypi/pep508_env.bzl

@@ -16,6 +16,14 @@
 """
 
 # See https://stackoverflow.com/questions/45125516/possible-values-for-uname-m
+_platform_machine_aliases = {
+    # These pairs mean the same hardware, but different values may be used
+    # on different host platforms.
+    "amd64": "x86_64",
+    "arm64": "aarch64",
+    "i386": "x86_32",
+    "i686": "x86_32",
+}
 _platform_system_values = {
     "linux": "Linux",
     "osx": "Darwin",
@@ -74,7 +82,11 @@ def env(target_platform, *, extra = None):
         }
 
     # This is split by topic
-    return env
+    return env | {
+        "_aliases": {
+            "platform_machine": _platform_machine_aliases,
+        },
+    }
 
 def _platform(*, abi = None, os = None, arch = None):
     return struct(

python/private/pypi/pep508_evaluate.bzl

@@ -56,16 +56,7 @@ _NON_VERSION_VAR_NAMES = [
 _AND = "and"
 _OR = "or"
 _NOT = "not"
-_VALUE_ALIASES = {
-    "platform_machine": {
-        # These pairs mean the same hardware, but different values may be used
-        # on different host platforms.
-        "amd64": "x86_64",
-        "arm64": "aarch64",
-        "i386": "x86_32",
-        "i686": "x86_32",
-    },
-}
+_ENV_ALIASES = "_aliases"
 
 def tokenize(marker):
     """Tokenize the input string.
@@ -133,17 +124,13 @@ def tokenize(marker):
 
     return fail("BUG: failed to process the marker in allocated cycles: {}".format(marker))
 
-def evaluate(marker, *, env, strict = True, value_aliases = _VALUE_ALIASES, **kwargs):
+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.
-        value_aliases: {type}`dict` The value normalization to do for certain
-            fields to ensure that `aarch64` evaluation in the `platform_machine`
-            works the same way irrespective if the marker uses `arm64` or
-            `aarch64` value in the expression.
         **kwargs: Extra kwargs to be passed to the expression evaluator.
 
     Returns:
@@ -156,7 +143,7 @@ def evaluate(marker, *, env, strict = True, value_aliases = _VALUE_ALIASES, **kw
         if not tokens:
             break
 
-        tokens = ast.parse(env = env, tokens = tokens, strict = strict, value_aliases = value_aliases)
+        tokens = ast.parse(env = env, tokens = tokens, strict = strict)
 
     if not tokens:
         return ast.value()
@@ -250,7 +237,7 @@ def _new_expr(
     )
     return self
 
-def _parse(self, *, env, tokens, strict = False, value_aliases = {}):
+def _parse(self, *, env, tokens, strict = False):
     """The parse function takes the consumed tokens and returns the remaining."""
     token, remaining = tokens[0], tokens[1:]
 
@@ -265,7 +252,7 @@ def _parse(self, *, env, tokens, strict = False, value_aliases = {}):
     elif token == _NOT:
         expr = _not_expr(self)
     else:
-        expr = marker_expr(env = env, strict = strict, value_aliases = value_aliases, *tokens[:3])
+        expr = marker_expr(env = env, strict = strict, *tokens[:3])
         remaining = tokens[3:]
 
     _append(self, expr)
@@ -291,7 +278,7 @@ def _value(self):
 
     fail("BUG: invalid state: {}".format(self.tree))
 
-def marker_expr(left, op, right, *, env, strict = True, value_aliases = {}):
+def marker_expr(left, op, right, *, env, strict = True):
     """Evaluate a marker expression
 
     Args:
@@ -301,8 +288,11 @@ def marker_expr(left, op, right, *, env, strict = True, value_aliases = {}):
         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 `<left> <op> <right>` expression.
-        value_aliases: the value normalization used for certain fields.
+            the `<left> <op> <right>` expression. Note, if `env` has a key
+            "_aliases", then we will do normalization so that we can ensure
+            that e.g. `aarch64` evaluation in the `platform_machine` works the
+            same way irrespective if the marker uses `arm64` or `aarch64` value
+            in the expression.
 
     Returns:
         {type}`bool` if the expression evaluation result or {type}`str` if the expression
@@ -316,19 +306,21 @@ def marker_expr(left, op, right, *, env, strict = True, value_aliases = {}):
         right = env[right]
         left = left.strip("\"")
 
-        # On Windows, Linux, OSX different values may mean the same hardware,
-        # e.g. Python on Windows returns arm64, but on Linux returns aarch64.
-        # e.g. Python on Windows returns amd64, but on Linux returns x86_64.
-        #
-        # The following normalizes the values
-        left = value_aliases.get(var_name, {}).get(left, left)
+        if _ENV_ALIASES in env:
+            # On Windows, Linux, OSX different values may mean the same hardware,
+            # e.g. Python on Windows returns arm64, but on Linux returns aarch64.
+            # e.g. Python on Windows returns amd64, but on Linux returns x86_64.
+            #
+            # The following normalizes the values
+            left = env.get(_ENV_ALIASES, {}).get(var_name, {}).get(left, left)
     else:
         var_name = left
         left = env[left]
         right = right.strip("\"")
 
-        # See the note above on normalization
-        right = value_aliases.get(var_name, {}).get(right, right)
+        if _ENV_ALIASES in env:
+            # See the note above on normalization
+            right = env.get(_ENV_ALIASES, {}).get(var_name, {}).get(right, right)
 
     if var_name in _NON_VERSION_VAR_NAMES:
         return _env_expr(left, op, right)