Merge remote-tracking branch 'origin/main' into integration-tests

Author: ytausch

conda_forge_tick/migrators/cross_compile.py

@@ -148,8 +148,14 @@ def migrate(self, recipe_dir: str, attrs: "AttrsTypedDict", **kwargs: Any) -> No
                 f.write("".join(lines))
 
 
-class CrossPythonMigrator(CrossCompilationMigratorBase):
+class CrossPythonMigrator(MiniMigrator):
+    allowed_schema_versions = {0, 1}
+    post_migration = True
+
     def filter(self, attrs: "AttrsTypedDict", not_bad_str_start: str = "") -> bool:
+        if super().filter(attrs, not_bad_str_start):
+            return True
+
         host_reqs = attrs.get("requirements", {}).get("host", set())
         build_reqs = attrs.get("requirements", {}).get("build", set())
         return (
@@ -161,7 +167,8 @@ def filter(self, attrs: "AttrsTypedDict", not_bad_str_start: str = "") -> bool:
     def migrate(self, recipe_dir: str, attrs: "AttrsTypedDict", **kwargs: Any) -> None:
         host_reqs = attrs.get("requirements", {}).get("host", set())
         with pushd(recipe_dir):
-            with open("meta.yaml") as f:
+            recipe_file = next(filter(os.path.exists, ("recipe.yaml", "meta.yaml")))
+            with open(recipe_file) as f:
                 lines = f.readlines()
             in_reqs = False
             for i, line in enumerate(lines):
@@ -189,24 +196,37 @@ def migrate(self, recipe_dir: str, attrs: "AttrsTypedDict", **kwargs: Any) -> No
                     for pkg in reversed(
                         [
                             "python",
-                            "cross-python_{{ target_platform }}",
+                            (
+                                "cross-python_${{ host_platform }}"
+                                if recipe_file == "recipe.yaml"
+                                else "cross-python_{{ target_platform }}"
+                            ),
                             "cython",
                             "numpy",
                             "cffi",
                             "pybind11",
                         ],
                     ):
                         if pkg in host_reqs or pkg.startswith("cross-python"):
-                            new_line = (
-                                " " * spaces
-                                + "- "
-                                + pkg.ljust(37)
-                                + "  # [build_platform != target_platform]\n"
-                            )
-                            lines.insert(i + 1, new_line)
+                            if recipe_file == "recipe.yaml":
+                                new_line = (
+                                    " " * spaces
+                                    + "- if: build_platform != host_platform\n"
+                                )
+                                lines.insert(i + 1, new_line)
+                                new_line = " " * spaces + f"  then: {pkg}\n"
+                                lines.insert(i + 2, new_line)
+                            else:
+                                new_line = (
+                                    " " * spaces
+                                    + "- "
+                                    + pkg.ljust(37)
+                                    + "  # [build_platform != target_platform]\n"
+                                )
+                                lines.insert(i + 1, new_line)
                     break
 
-            with open("meta.yaml", "w") as f:
+            with open(recipe_file, "w") as f:
                 f.write("".join(lines))
 
 
@@ -325,20 +345,24 @@ def migrate(self, recipe_dir: str, attrs: "AttrsTypedDict", **kwargs: Any) -> No
 """
 
 
-class CrossRBaseMigrator(CrossCompilationMigratorBase):
+class CrossRBaseMigrator(MiniMigrator):
+    allowed_schema_versions = {0, 1}
+    post_migration = True
+
     def filter(self, attrs: "AttrsTypedDict", not_bad_str_start: str = "") -> bool:
+        if super().filter(attrs, not_bad_str_start):
+            return True
+
         host_reqs = attrs.get("requirements", {}).get("host", set())
-        skip_schema = skip_migrator_due_to_schema(attrs, self.allowed_schema_versions)
-        if (
-            "r-base" in host_reqs or attrs.get("name", "").startswith("r-")
-        ) and not skip_schema:
+        if "r-base" in host_reqs or attrs.get("name", "").startswith("r-"):
             return False
         else:
             return True
 
     def migrate(self, recipe_dir: str, attrs: "AttrsTypedDict", **kwargs: Any) -> None:
         with pushd(recipe_dir):
-            with open("meta.yaml") as fp:
+            recipe_file = next(filter(os.path.exists, ("recipe.yaml", "meta.yaml")))
+            with open(recipe_file) as fp:
                 meta_yaml = fp.readlines()
 
             new_lines = []
@@ -347,10 +371,20 @@ def migrate(self, recipe_dir: str, attrs: "AttrsTypedDict", **kwargs: Any) -> No
             for line in meta_yaml:
                 if previous_was_build:
                     nspaces = len(line) - len(line.lstrip())
-                    new_lines.append(
-                        " " * nspaces
-                        + "- cross-r-base {{ r_base }}  # [build_platform != target_platform]\n",
-                    )
+                    if recipe_file == "recipe.yaml":
+                        new_lines.extend(
+                            [
+                                " " * nspaces
+                                + "- if: build_platform != host_platform\n",
+                                " " * nspaces + "  then:\n",
+                                " " * nspaces + "    - cross-r-base ${{ r_base }}\n",
+                            ]
+                        )
+                    else:
+                        new_lines.append(
+                            " " * nspaces
+                            + "- cross-r-base {{ r_base }}  # [build_platform != target_platform]\n",
+                        )
                     # Add host R requirements to build
                     host_reqs = attrs.get("requirements", {}).get("host", set())
                     r_host_reqs = [
@@ -359,15 +393,18 @@ def migrate(self, recipe_dir: str, attrs: "AttrsTypedDict", **kwargs: Any) -> No
                         if req.startswith("r-") and req != "r-base"
                     ]
                     for r_req in r_host_reqs:
-                        # Ensure nice formatting
-                        post_nspaces = max(0, 25 - len(r_req))
-                        new_lines.append(
-                            " " * nspaces
-                            + "- "
-                            + r_req
-                            + " " * post_nspaces
-                            + "  # [build_platform != target_platform]\n",
-                        )
+                        if recipe_file == "recipe.yaml":
+                            new_lines.append(" " * nspaces + f"    - {r_req}\n")
+                        else:
+                            # Ensure nice formatting
+                            post_nspaces = max(0, 25 - len(r_req))
+                            new_lines.append(
+                                " " * nspaces
+                                + "- "
+                                + r_req
+                                + " " * post_nspaces
+                                + "  # [build_platform != target_platform]\n",
+                            )
                     in_req = False
                     previous_was_build = False
                 if "requirements:" in line:
@@ -376,7 +413,7 @@ def migrate(self, recipe_dir: str, attrs: "AttrsTypedDict", **kwargs: Any) -> No
                     previous_was_build = True
                 new_lines.append(line)
 
-            with open("meta.yaml", "w") as f:
+            with open(recipe_file, "w") as f:
                 f.write("".join(new_lines))
 
             if os.path.exists("build.sh"):

conda_forge_tick/migrators/recipe_v1.py

@@ -3,6 +3,10 @@
 from pathlib import Path
 from typing import Any
 
+from jinja2 import Environment
+from jinja2.nodes import Compare, Node, Not
+from jinja2.parser import Parser
+
 from conda_forge_tick.migrators.core import MiniMigrator
 from conda_forge_tick.recipe_parser._parser import _get_yaml_parser
 
@@ -12,56 +16,95 @@
 logger = logging.getLogger(__name__)
 
 
-def combine_conditions(node):
+def get_condition(node: Any) -> Node | None:
+    if isinstance(node, dict) and "if" in node:
+        return Parser(
+            Environment(), node["if"].strip(), state="variable"
+        ).parse_expression()
+    return None
+
+
+def is_same_condition(a: Node, b: Node) -> bool:
+    return a == b
+
+
+INVERSE_OPS = {
+    "eq": "ne",
+    "ne": "eq",
+    "gt": "lteq",
+    "gteq": "lt",
+    "lt": "gteq",
+    "lteq": "gt",
+    "in": "notin",
+    "notin": "in",
+}
+
+
+def is_negated_condition(a: Node, b: Node) -> bool:
+    # X <-> not X
+    if Not(a) == b or a == Not(b):
+        return True
+
+    # unwrap (not X) <-> (not Y)
+    if isinstance(a, Not) and isinstance(b, Not):
+        a = a.node
+        b = b.node
+
+    # A == B <-> A != B
+    if (
+        isinstance(a, Compare)
+        and isinstance(b, Compare)
+        and len(a.ops) == len(b.ops) == 1
+        and a.expr == b.expr
+        and a.ops[0].expr == b.ops[0].expr
+        and a.ops[0].op == INVERSE_OPS[b.ops[0].op]
+    ):
+        return True
+
+    return False
+
+
+def fold_branch(source: Any, dest: Any, branch: str, dest_branch: str) -> None:
+    if branch not in source:
+        return
+
+    source_l = source[branch]
+    if isinstance(source_l, str):
+        if dest_branch not in dest:
+            # special-case: do not expand a single string to list
+            dest[dest_branch] = source_l
+            return
+        source_l = [source_l]
+
+    if dest_branch not in dest:
+        dest[dest_branch] = []
+    elif isinstance(dest[dest_branch], str):
+        dest[dest_branch] = [dest[dest_branch]]
+    dest[dest_branch].extend(source_l)
+
+
+def combine_conditions(node: Any):
     """Breadth first recursive call to combine list conditions"""
 
     # recursion is breadth first because we go through each element here
     # before calling `combine_conditions` on any element in the node
     if isinstance(node, list):
-        # 1. loop through list elements, gather the if conditions
-
-        # condition ("if:") -> [(then, else), (then, else)...]
-        conditions = {}
-
-        for i in node:
-            if isinstance(i, dict) and "if" in i:
-                conditions.setdefault(i["if"], []).append((i["then"], i.get("else")))
-
-        # 2. if elements share a compatible if condition
-        # combine their if...then...else statements
-        to_drop = []
-        for i in range(len(node)):
-            if isinstance(node[i], dict) and "if" in node[i]:
-                condition = node[i]["if"]
-                if condition not in conditions:
-                    # already combined it, so drop the repeat instance
-                    to_drop.append(i)
-                    continue
-                if len(conditions[condition]) > 1:
-                    new_then = []
-                    new_else = []
-                    for sub_then, sub_else in conditions[node[i]["if"]]:
-                        if isinstance(sub_then, list):
-                            new_then.extend(sub_then)
-                        else:
-                            assert sub_then is not None
-                            new_then.append(sub_then)
-                        if isinstance(sub_else, list):
-                            new_else.extend(sub_else)
-                        elif sub_else is not None:
-                            new_else.append(sub_else)
-                    node[i]["then"] = new_then
-                    if new_else:
-                        # TODO: preserve inline "else" instead of converting it to a list?
-                        node[i]["else"] = new_else
-                    else:
-                        assert "else" not in node[i]
-                    # remove it from the dict, so we don't output it again
-                    del conditions[condition]
-
-        # drop the repeated conditions
-        for i in reversed(to_drop):
-            del node[i]
+        # iterate in reverse order, so we can remove elements on the fly
+        # start at index 1, since we can only fold to the previous node
+        for i in reversed(range(1, len(node))):
+            node_cond = get_condition(node[i])
+            prev_cond = get_condition(node[i - 1])
+            if node_cond is None or prev_cond is None:
+                continue
+
+            if is_same_condition(node_cond, prev_cond):
+                fold_branch(node[i], node[i - 1], "then", "then")
+                fold_branch(node[i], node[i - 1], "else", "else")
+                del node[i]
+            elif is_negated_condition(node_cond, prev_cond):
+                fold_branch(node[i], node[i - 1], "then", "else")
+                fold_branch(node[i], node[i - 1], "else", "then")
+                del node[i]
 
     # then we descend down the tree
     if isinstance(node, dict):