add v2 recipe editing capabilities for bumping version & build number

conda_forge_tick/hashing.py

@@ -2,12 +2,18 @@
 import hashlib
 import math
 import time
-from multiprocessing import Pipe, Process
+from multiprocessing import Pipe, Process, connection
 
 import requests
 
 
-def _hash_url(url, hash_type, progress=False, conn=None, timeout=None):
+def _hash_url(
+    url: str,
+    hash_type: str,
+    progress: bool = False,
+    conn: connection.Connection | None = None,
+    timeout: int | None = None,
+) -> str | None:
     _hash = None
     try:
         ha = getattr(hashlib, hash_type)()
@@ -68,7 +74,12 @@ def _hash_url(url, hash_type, progress=False, conn=None, timeout=None):
 
 
 @functools.lru_cache(maxsize=1024)
-def hash_url(url, timeout=None, progress=False, hash_type="sha256"):
+def hash_url(
+    url: str,
+    timeout: int | None = None,
+    progress: bool = False,
+    hash_type: str = "sha256",
+) -> str | None:
     """Hash a url with a timeout.
 
     Parameters

conda_forge_tick/migrators/core.py

@@ -5,6 +5,7 @@
 import logging
 import re
 import typing
+from pathlib import Path
 from typing import Any, List, Sequence, Set
 
 import dateutil.parser
@@ -14,7 +15,7 @@
 from conda_forge_tick.lazy_json_backends import LazyJson
 from conda_forge_tick.make_graph import make_outputs_lut_from_graph
 from conda_forge_tick.path_lengths import cyclic_topological_sort
-from conda_forge_tick.update_recipe import update_build_number
+from conda_forge_tick.update_recipe import update_build_number, v2
 from conda_forge_tick.utils import (
     frozen_to_json_friendly,
     get_bot_run_url,
@@ -560,25 +561,27 @@
         }
         return cyclic_topological_sort(graph, top_level)
 
-    def set_build_number(self, filename: str) -> None:
+    def set_build_number(self, filename: str | Path) -> None:
         """Bump the build number of the specified recipe.
 
         Parameters
         ----------
         filename : str
             Path the the meta.yaml
         """
-        with open(filename) as f:
-            raw = f.read()
+        filename = Path(filename)
+        if filename.name == "recipe.yaml":
+            filename.write_text(v2.update_build_number(filename, self.new_build_number))
+        else:
+            raw = filename.read_text()
 
-        new_myaml = update_build_number(
-            raw,
-            self.new_build_number,
-            build_patterns=self.build_patterns,
-        )
+            new_myaml = update_build_number(
+                raw,
+                self.new_build_number,
+                build_patterns=self.build_patterns,
+            )
 
-        with open(filename, "w") as f:
-            f.write(new_myaml)
+            filename.write_text(new_myaml)
 
     def new_build_number(self, old_number: int) -> int:
         """Determine the new build number to use.

conda_forge_tick/migrators/version.py

@@ -5,6 +5,7 @@
 import random
 import typing
 import warnings
+from pathlib import Path
 from typing import Any, List, Sequence
 
 import conda.exceptions
@@ -14,9 +15,8 @@
 from conda_forge_tick.contexts import FeedstockContext
 from conda_forge_tick.migrators.core import Migrator
 from conda_forge_tick.models.pr_info import MigratorName
-from conda_forge_tick.os_utils import pushd
 from conda_forge_tick.update_deps import get_dep_updates_and_hints
-from conda_forge_tick.update_recipe import update_version
+from conda_forge_tick.update_recipe import update_version, v2
 from conda_forge_tick.utils import get_keys_default, sanitize_string
 
 if typing.TYPE_CHECKING:
@@ -195,29 +195,37 @@
     ) -> "MigrationUidTypedDict":
         version = attrs["new_version"]
 
-        with open(os.path.join(recipe_dir, "meta.yaml")) as fp:
-            raw_meta_yaml = fp.read()
+        recipe_dir = Path(recipe_dir)
+        meta_yaml = recipe_dir / "meta.yaml"
+        recipe_yaml = recipe_dir / "recipe.yaml"
+        if meta_yaml.exists():
+            raw_meta_yaml = meta_yaml.read_text()
 
-        updated_meta_yaml, errors = update_version(
-            raw_meta_yaml,
-            version,
-            hash_type=hash_type,
-        )
+            updated_meta_yaml, errors = update_version(
+                raw_meta_yaml,
+                version,
+                hash_type=hash_type,
+            )
 
-        if len(errors) == 0 and updated_meta_yaml is not None:
-            with pushd(recipe_dir):
-                with open("meta.yaml", "w") as fp:
-                    fp.write(updated_meta_yaml)
-                self.set_build_number("meta.yaml")
+            if len(errors) == 0 and updated_meta_yaml is not None:
+                meta_yaml.write_text(updated_meta_yaml)
+                self.set_build_number(meta_yaml)
 
-            return super().migrate(recipe_dir, attrs)
-        else:
+        elif recipe_yaml.exists():
+            updated_recipe, errors = v2.update_version(recipe_yaml, version)
+            if len(errors) == 0 and updated_recipe is not None:
+                recipe_yaml.write_text(updated_recipe)
+                self.set_build_number(recipe_yaml)
+
+        if len(errors) != 0:
             raise VersionMigrationError(
                 _fmt_error_message(
                     errors,
                     version,
                 )
             )
+        else:
+            return super().migrate(recipe_dir, attrs)
 
     def pr_body(self, feedstock_ctx: FeedstockContext, add_label_text=False) -> str:
         if feedstock_ctx.feedstock_name in self.effective_graph.nodes:

conda_forge_tick/update_recipe/v2/__init__.py

@@ -0,0 +1,4 @@
+from .build_number import update_build_number
+from .version import update_version
+
+__all__ = ["update_build_number", "update_version"]

conda_forge_tick/update_recipe/v2/build_number.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Literal
+
+from conda_forge_tick.update_recipe.v2.yaml import _dump_yaml_to_str, _load_yaml
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+HashType = Literal["md5", "sha256"]
+
+
+def _update_build_number_in_context(
+    recipe: dict[str, Any], new_build_number: int
+) -> bool:
+    for key in recipe.get("context", {}):
+        if key.startswith("build_") or key == "build":
+            recipe["context"][key] = new_build_number
+            return True
+    return False
+
+
+def _update_build_number_in_recipe(
+    recipe: dict[str, Any], new_build_number: int
+) -> bool:
+    is_modified = False
+    if "build" in recipe and "number" in recipe["build"]:
+        recipe["build"]["number"] = new_build_number
+        is_modified = True
+
+    if "outputs" in recipe:
+        for output in recipe["outputs"]:
+            if "build" in output and "number" in output["build"]:
+                output["build"]["number"] = new_build_number
+                is_modified = True
+
+    return is_modified
+
+
+def update_build_number(file: Path, new_build_number: int = 0) -> str:
+    """
+    Update the build number in the recipe file.
+
+    Arguments:
+    ----------
+    * `file` - The path to the recipe file.
+    * `new_build_number` - The new build number to use. (default: 0)
+
+    Returns:
+    --------
+    * The updated recipe as a string.
+    """
+    data = _load_yaml(file)
+    build_number_modified = _update_build_number_in_context(data, new_build_number)
+    if not build_number_modified:
+        _update_build_number_in_recipe(data, new_build_number)
+
+    return _dump_yaml_to_str(data)

conda_forge_tick/update_recipe/v2/conditional_list.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Generic, List, TypeVar, Union, cast
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Generator
+
+T = TypeVar("T")
+K = TypeVar("K")
+
+
+class IfStatement(Generic[T]):
+    if_: Any
+    then: T | list[T]
+    else_: T | list[T] | None
+
+
+ConditionalList = Union[T, IfStatement[T], List[Union[T, IfStatement[T]]]]
+
+
+def visit_conditional_list(  # noqa: C901
+    value: T | IfStatement[T] | list[T | IfStatement[T]],
+    evaluator: Callable[[Any], bool] | None = None,
+) -> Generator[T]:
+    """
+    A function that yields individual branches of a conditional list.
+
+    Arguments
+    ---------
+    * `value` - The value to evaluate
+    * `evaluator` - An optional evaluator to evaluate the `if` expression.
+
+    Returns
+    -------
+    A generator that yields the individual branches.
+    """
+
+    def yield_from_list(value: list[K] | K) -> Generator[K]:
+        if isinstance(value, list):
+            yield from value
+        else:
+            yield value
+
+    if not isinstance(value, list):
+        value = [value]
+
+    for element in value:
+        if isinstance(element, dict):
+            if (expr := element.get("if", None)) is not None:
+                then = element.get("then")
+                otherwise = element.get("else")
+                # Evaluate the if expression if the evaluator is provided
+                if evaluator:
+                    if evaluator(expr):
+                        yield from yield_from_list(then)
+                    elif otherwise:
+                        yield from yield_from_list(otherwise)
+                # Otherwise, just yield the branches
+                else:
+                    yield from yield_from_list(then)
+                    if otherwise:
+                        yield from yield_from_list(otherwise)
+            else:
+                # In this case its not an if statement
+                yield cast(T, element)
+        # If the element is not a dictionary, just yield it
+        else:
+            # (tim) I get a pyright error here, but I don't know how to fix it
+            yield cast(T, element)

conda_forge_tick/update_recipe/v2/context.py

@@ -0,0 +1,19 @@
+import jinja2
+
+
+def load_recipe_context(
+    context: dict[str, str], jinja_env: jinja2.Environment
+) -> dict[str, str]:
+    """
+    Load all string values from the context dictionary as Jinja2 templates.
+    Use linux-64 as default target_platform, build_platform, and mpi.
+    """
+    # Process each key-value pair in the dictionary
+    for key, value in context.items():
+        # If the value is a string, render it as a template
+        if isinstance(value, str):
+            template = jinja_env.from_string(value)
+            rendered_value = template.render(context)
+            context[key] = rendered_value
+
+    return context

conda_forge_tick/update_recipe/v2/jinja/__init__.py

@@ -0,0 +1,3 @@
+from .jinja import jinja_env
+
+__all__ = ["jinja_env"]

conda_forge_tick/update_recipe/v2/jinja/filters.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from conda_forge_tick.update_recipe.v2.jinja.utils import _MissingUndefined
+
+
+def _version_to_build_string(some_string: str | _MissingUndefined) -> str:
+    """
+    Converts some version by removing the . character and returning only the first two elements of the version.
+    If piped value is undefined, it returns the undefined value as is.
+    """
+    if isinstance(some_string, _MissingUndefined):
+        return f"{some_string._undefined_name}_version_to_build_string"  # noqa: SLF001
+    # We first split the string by whitespace and take the first part
+    split = some_string.split()[0] if some_string.split() else some_string
+    # We then split the string by . and take the first two parts
+    parts = split.split(".")
+    major = parts[0] if len(parts) > 0 else ""
+    minor = parts[1] if len(parts) > 1 else ""
+    return f"{major}{minor}"
+
+
+def _bool(value: str) -> bool:
+    return bool(value)
+
+
+def _split(s: str, sep: str | None = None) -> list[str]:
+    """Filter that split a string by a separator"""
+    return s.split(sep)