Merge pull request regro#3935 from mgorny/v1-combine-not

beckermr · web-flow · commit 485a852f7aa4 · 2025-03-26T00:48:09.000Z
Support combining trivial negations in v1 recipes
diff --git a/conda_forge_tick/migrators/recipe_v1.py b/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,28 +16,71 @@
 logger = logging.getLogger(__name__)
 
 
-def is_same_condition(a: Any, b: Any) -> bool:
-    return (
-        isinstance(a, dict)
-        and isinstance(b, dict)
-        and "if" in a
-        and "if" in b
-        and a["if"] == b["if"]
-    )
+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
 
-def fold_branch(source: Any, dest: Any, branch: str) -> None:
+    # 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 branch not in dest:
-        dest[branch] = []
-    elif isinstance(dest[branch], str):
-        dest[branch] = [dest[branch]]
-    dest[branch].extend(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):
@@ -45,9 +92,18 @@ def combine_conditions(node: Any):
         # 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))):
-            if is_same_condition(node[i], node[i - 1]):
-                fold_branch(node[i], node[i - 1], "then")
-                fold_branch(node[i], node[i - 1], "else")
+            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
diff --git a/tests/test_recipe_v1.py b/tests/test_recipe_v1.py
@@ -1,12 +1,17 @@
 from pathlib import Path
 
+import pytest
 from flaky import flaky
 from test_migrators import run_test_migration
 
 from conda_forge_tick.migrators import (
     CombineV1ConditionsMigrator,
     Version,
 )
+from conda_forge_tick.migrators.recipe_v1 import (
+    get_condition,
+    is_negated_condition,
+)
 
 YAML_PATH = Path(__file__).parent / "test_v1_yaml"
 
@@ -16,6 +21,53 @@
 )
 
 
+@pytest.mark.parametrize(
+    "a,b",
+    [
+        ("unix", "not unix"),
+        ('cuda_compiler_version == "None"', 'not cuda_compiler_version == "None"'),
+        ('cuda_compiler_version == "None"', 'cuda_compiler_version != "None"'),
+        ('not cuda_compiler_version == "None"', 'not cuda_compiler_version != "None"'),
+        (
+            'cuda_compiler_version != "None" and linux',
+            'not (cuda_compiler_version != "None" and linux)',
+        ),
+        ("linux or osx", "not (linux or osx)"),
+        ("a >= 14", "a < 14"),
+        ("a >= 14", "not (a >= 14)"),
+        ("a in [1, 2, 3]", "a not in [1, 2, 3]"),
+        ("a in [1, 2, 3]", "not a in [1, 2, 3]"),
+        ("a + b < 10", "a + b >= 10"),
+        ("a == b == c", "not (a == b == c)"),
+    ],
+)
+def test_is_negated_condition(a, b):
+    a_cond = get_condition({"if": a})
+    b_cond = get_condition({"if": b})
+    assert is_negated_condition(a_cond, b_cond)
+    assert is_negated_condition(b_cond, a_cond)
+
+
+@pytest.mark.parametrize(
+    "a,b",
+    [
+        ("not unix", "not unix"),
+        ('cuda_compiler_version == "None"', 'not cuda_compiler_version != "None"'),
+        ('cuda_compiler_version != "None"', 'not cuda_compiler_version == "None"'),
+        ("a or b", "not a or b"),
+        ("a and b", "not a and b"),
+        ("a == b == c", "a != b != c"),
+        ("a > 4", "a < 4"),
+        ("a == b == c", "not (a == b) == c"),
+    ],
+)
+def test_not_is_negated_condition(a, b):
+    a_cond = get_condition({"if": a})
+    b_cond = get_condition({"if": b})
+    assert not is_negated_condition(a_cond, b_cond)
+    assert not is_negated_condition(b_cond, a_cond)
+
+
 @flaky
 def test_combine_v1_conditions(tmp_path):
     run_test_migration(
diff --git a/tests/test_v1_yaml/version_pytorch_correct.yaml b/tests/test_v1_yaml/version_pytorch_correct.yaml
@@ -39,8 +39,7 @@ outputs:
               then:
                 - python 3.12.*
                 - numpy  *
-            - if: not megabuild
-              then:
+              else:
                 - python
                 - numpy
             - cross-python_${{ target_platform }}
@@ -51,8 +50,7 @@ outputs:
           then: ${{ compiler('cuda') }}
         - if: not win
           then: llvm-openmp
-        - if: win
-          then:
+          else:
             - intel-openmp ${{ mkl }}
             - libuv
         - cmake
@@ -123,8 +121,7 @@ outputs:
             - liblapack
         - if: not win
           then: llvm-openmp
-        - if: win
-          then: intel-openmp ${{ mkl }}
+          else: intel-openmp ${{ mkl }}
         - libabseil
         - libprotobuf
         - sleef
@@ -152,8 +149,7 @@ outputs:
           else:
             - pytorch-gpu ==${{ version }}
             - pytorch-cpu ==99999999
-        - if: "cuda_compiler_version != \"None\""
-          then: pytorch =${{ version }} cuda${{ cuda_compiler_version | replace('.', '') }}_${{ blas_impl }}_*_${{ build }}
+            - pytorch =${{ version }} cuda${{ cuda_compiler_version | replace('.', '') }}_${{ blas_impl }}_*_${{ build }}
         - if: "unix and blas_impl != \"mkl\""
           then: openblas * openmp_*
 
@@ -230,12 +226,10 @@ outputs:
             - libcblas * *_mkl
           else:
             - libcblas
-        - if: "blas_impl != \"mkl\""
-          then: liblapack
+            - liblapack
         - if: not win
           then: llvm-openmp
-        - if: win
-          then: intel-openmp ${{ mkl }}
+          else: intel-openmp ${{ mkl }}
         - libabseil
         - libprotobuf
         - pybind11
@@ -251,17 +245,13 @@ outputs:
           then: ${{ pin_subpackage('libtorch', exact=True) }}
         # for non-megabuild, allow libtorch from any python version;
         # pinning build number would be nice but breaks conda
-        - if: not megabuild
-          then: libtorch ${{ version }}.*
+          else: libtorch ${{ version }}.*
         - if: not win
           then: llvm-openmp
-        - if: win
-          then: intel-openmp ${{ mkl }}
+          else: intel-openmp ${{ mkl }}
         - if: "blas_impl == \"mkl\""
           then: libblas * *${{ blas_impl }}
-        - if: "blas_impl != \"mkl\""
-          then: nomkl
-        # GPU requirements without run_exports
+          else: nomkl
         - if: "cuda_compiler_version != \"None\""
           then: ${{ pin_compatible('cudnn') }}
         - if: "cuda_compiler_version != \"None\" and not win"
