refactor(forks): refactor extract fork until from logic (#2051)

* feat(forks): Add helpers and adapters

* refactor(plugins): Refactor validity marker logic

* feat(forks): Add `children` method

* feat(forks): Add BPO and transition forks to get_selected_fork_set

* fix: tox

* fix(forks): Rollback including BPO forks by default

* chore(docs): update changelog.

---------

Co-authored-by: spencer-tb <[email protected]>

Author: marioevz

docs/CHANGELOG.md

@@ -12,6 +12,7 @@ Test fixtures for use by clients are available for each release on the [Github r
 - Tests for the Prague fork are now marked as stable will be included in the `fixtures_stable.tar.gz` tarball from now on.
 - Tests for the Osaka fork are now included in the `fixtures_develop.tar.gz` tarball.
 - `fixtures_static.tar.gz` has been deprecated and filled static tests are now included in `fixtures_stable.tar.gz` and `fixtures_develop.tar.gz`.
+- When filling fixtures transition forks are included within there respective "to" fork, where `--fork Osaka` will now include `PragueToOsakaAtTime15k`. Previously transitions fork would only be included when filling with `--from Prague --until Osaka` flags.
 
 #### 💥 Important Change for EEST developers
 
@@ -64,6 +65,7 @@ Users can select any of the artifacts depending on their testing needs for their
 - ✨ Opcode classes now validate keyword arguments and raise `ValueError` with clear error messages.
 - 🔀 This PR removes the `solc` requirement to fill Python test cases. Regular test contributors no longer need to concern themselves with `solc` and, as such, the `solc-select` dependency has been removed. The remaining tests that used Yul have been ported to the EEST opcode wrapper mini-lang and the use of Yul in Python tests is no longer supported. Maintainers only: To fill the "static" JSON and YAML tests (`./tests/static/`) locally, `solc` (ideally v0.8.24) must be available in your PATH.
 - 🔀 Updated default block gas limit from 36M to 45M to match mainnet environment.
+- 🔀 Refactor fork logic to include transition forks within there "to" fork ([#2051](https://github.com/ethereum/execution-spec-tests/pull/2051)).
 
 #### `fill`
 

src/ethereum_test_forks/__init__.py

@@ -37,10 +37,19 @@
 )
 from .gas_costs import GasCosts
 from .helpers import (
+    ALL_FORKS,
+    ALL_FORKS_WITH_TRANSITIONS,
+    ALL_TRANSITION_FORKS,
     Fork,
+    ForkAdapter,
+    ForkOrNoneAdapter,
     ForkRangeDescriptor,
+    ForkSet,
+    ForkSetAdapter,
     InvalidForkError,
     TransitionFork,
+    TransitionForkAdapter,
+    TransitionForkOrNoneAdapter,
     forks_from,
     forks_from_until,
     get_closest_fork,
@@ -53,6 +62,7 @@
     get_from_until_fork_set,
     get_last_descendants,
     get_relative_fork_markers,
+    get_selected_fork_set,
     get_transition_fork_predecessor,
     get_transition_fork_successor,
     get_transition_forks,
@@ -61,8 +71,17 @@
 )
 
 __all__ = [
+    "ALL_FORKS_WITH_TRANSITIONS",
+    "ALL_FORKS",
+    "ALL_TRANSITION_FORKS",
     "Fork",
+    "ForkAdapter",
+    "ForkOrNoneAdapter",
+    "ForkSet",
+    "ForkSetAdapter",
     "TransitionFork",
+    "TransitionForkAdapter",
+    "TransitionForkOrNoneAdapter",
     "ForkAttribute",
     "ArrowGlacier",
     "Berlin",
@@ -111,6 +130,7 @@
     "get_forks",
     "get_from_until_fork_set",
     "get_last_descendants",
+    "get_selected_fork_set",
     "transition_fork_from_to",
     "transition_fork_to",
     "GasCosts",

src/ethereum_test_forks/base_fork.py

@@ -10,6 +10,7 @@
     Mapping,
     Optional,
     Protocol,
+    Set,
     Sized,
     Tuple,
     Type,
@@ -166,6 +167,7 @@ class BaseFork(ABC, metaclass=BaseForkMeta):
     _solc_name: ClassVar[Optional[str]] = None
     _ignore: ClassVar[bool] = False
     _bpo_fork: ClassVar[bool] = False
+    _children: ClassVar[Set[Type["BaseFork"]]] = set()
 
     # make mypy happy
     BLOB_CONSTANTS: ClassVar[Dict[str, Union[int, Literal["big"]]]] = {}
@@ -188,6 +190,11 @@ def __init_subclass__(
         cls._solc_name = solc_name
         cls._ignore = ignore
         cls._bpo_fork = bpo_fork
+        cls._children = set()
+        base_class = cls.__bases__[0]
+        assert issubclass(base_class, BaseFork)
+        if base_class != BaseFork:
+            base_class._children.add(cls)
 
     # Header information abstract methods
     @classmethod
@@ -630,3 +637,8 @@ def parent(cls) -> Type["BaseFork"] | None:
         if base_class == BaseFork:
             return None
         return base_class
+
+    @classmethod
+    def children(cls) -> Set[Type["BaseFork"]]:
+        """Return the children forks."""
+        return set(cls._children)

src/ethereum_test_forks/helpers.py

@@ -1,13 +1,15 @@
 """Helper methods to resolve forks during test filling."""
 
 import re
-from typing import Annotated, Any, Callable, List, Optional, Set, Type
+from typing import Annotated, Any, Callable, FrozenSet, List, Optional, Set, Type
 
 from pydantic import (
     BaseModel,
+    BeforeValidator,
     ConfigDict,
     PlainSerializer,
     PlainValidator,
+    TypeAdapter,
     ValidatorFunctionWrapHandler,
     model_validator,
 )
@@ -43,13 +45,20 @@ def __init__(self, message):
     if issubclass(fork, TransitionBaseClass) and issubclass(fork, BaseFork):
         transition_forks.append(fork)
 
+ALL_FORKS = frozenset(fork for fork in all_forks if not fork.ignore())
+
+ALL_TRANSITION_FORKS = frozenset(transition_forks)
+ALL_FORKS_WITH_TRANSITIONS = frozenset(
+    fork for fork in ALL_FORKS | ALL_TRANSITION_FORKS if not fork.ignore()
+)
+
 
 def get_forks() -> List[Type[BaseFork]]:
     """
     Return list of all the fork classes implemented by
     `ethereum_test_forks` ordered chronologically by deployment.
     """
-    return all_forks
+    return all_forks[:]
 
 
 def get_deployed_forks() -> List[Type[BaseFork]]:
@@ -86,7 +95,7 @@ def get_closest_fork(fork: Type[BaseFork], solc_version: Version) -> Optional[Ty
 
 def get_transition_forks() -> Set[Type[BaseFork]]:
     """Return all the transition forks."""
-    return set(transition_forks)
+    return set(ALL_TRANSITION_FORKS)
 
 
 def get_transition_fork_predecessor(transition_fork: Type[BaseFork]) -> Type[BaseFork]:
@@ -104,7 +113,9 @@ def get_transition_fork_successor(transition_fork: Type[BaseFork]) -> Type[BaseF
 
 
 def get_from_until_fork_set(
-    forks: Set[Type[BaseFork]], forks_from: Set[Type[BaseFork]], forks_until: Set[Type[BaseFork]]
+    forks: Set[Type[BaseFork]] | FrozenSet[Type[BaseFork]],
+    forks_from: Set[Type[BaseFork]],
+    forks_until: Set[Type[BaseFork]],
 ) -> Set[Type[BaseFork]]:
     """Get fork range from forks_from to forks_until."""
     resulting_set = set()
@@ -116,7 +127,9 @@ def get_from_until_fork_set(
     return resulting_set
 
 
-def get_forks_with_no_parents(forks: Set[Type[BaseFork]]) -> Set[Type[BaseFork]]:
+def get_forks_with_no_parents(
+    forks: Set[Type[BaseFork]] | FrozenSet[Type[BaseFork]],
+) -> Set[Type[BaseFork]]:
     """Get forks with no parents in the inheritance hierarchy."""
     resulting_forks: Set[Type[BaseFork]] = set()
     for fork in forks:
@@ -157,6 +170,30 @@ def get_last_descendants(
     return resulting_forks
 
 
+def get_selected_fork_set(
+    single_fork: Set[Type[BaseFork]],
+    forks_from: Set[Type[BaseFork]],
+    forks_until: Set[Type[BaseFork]],
+) -> Set[Type[BaseFork]]:
+    """
+    Process sets derived from `--fork`, `--until` and `--from` to return an unified fork
+    set.
+    """
+    selected_fork_set = set()
+    if single_fork:
+        selected_fork_set |= single_fork
+    else:
+        if not forks_from:
+            forks_from = get_forks_with_no_parents(ALL_FORKS)
+        if not forks_until:
+            forks_until = get_last_descendants(set(get_deployed_forks()), forks_from)
+        selected_fork_set = get_from_until_fork_set(ALL_FORKS, forks_from, forks_until)
+    for fork in list(selected_fork_set):
+        transition_fork_set = transition_fork_to(fork)
+        selected_fork_set |= transition_fork_set
+    return selected_fork_set
+
+
 def transition_fork_from_to(
     fork_from: Type[BaseFork], fork_to: Type[BaseFork]
 ) -> Type[BaseFork] | None:
@@ -316,7 +353,7 @@ def fork_validator_generator(
     cls_name: str, forks: List[Type[BaseFork]]
 ) -> Callable[[Any], Type[BaseFork]]:
     """Generate a fork validator function."""
-    forks_dict = {fork.name(): fork for fork in forks}
+    forks_dict = {fork.name().lower(): fork for fork in forks}
 
     def fork_validator(obj: Any) -> Type[BaseFork]:
         """Get a fork by name or raise an error."""
@@ -325,21 +362,41 @@ def fork_validator(obj: Any) -> Type[BaseFork]:
         if isinstance(obj, type) and issubclass(obj, BaseFork):
             return obj
         if isinstance(obj, str):
-            if obj in forks_dict:
-                return forks_dict[obj]
+            if obj.lower() in forks_dict:
+                return forks_dict[obj.lower()]
+            else:
+                raise InvalidForkError(f"Invalid fork '{obj}' specified")
         raise InvalidForkError(f"Invalid {cls_name}: {obj} (type: {type(obj)})")
 
     return fork_validator
 
 
+def set_before_validator(value: Any) -> Any:
+    """Convert a comma-separated string to a validation input for a set."""
+    if isinstance(value, str):
+        if value.strip() == "":
+            return set()
+        return {v.strip() for v in value.split(",")}
+    return value
+
+
 # Annotated Pydantic-Friendly Fork Types
 Fork = Annotated[
     Type[BaseFork],
     PlainSerializer(str),
     PlainValidator(fork_validator_generator("Fork", all_forks + transition_forks)),
 ]
+ForkAdapter: TypeAdapter = TypeAdapter(Fork)
+ForkOrNoneAdapter: TypeAdapter = TypeAdapter(Fork | None)
+ForkSet = Annotated[
+    Set[Fork],
+    BeforeValidator(set_before_validator),
+]
+ForkSetAdapter: TypeAdapter = TypeAdapter(ForkSet)
 TransitionFork = Annotated[
     Type[BaseFork],
     PlainSerializer(str),
     PlainValidator(fork_validator_generator("TransitionFork", transition_forks)),
 ]
+TransitionForkAdapter: TypeAdapter = TypeAdapter(TransitionFork)
+TransitionForkOrNoneAdapter: TypeAdapter = TypeAdapter(TransitionFork | None)

src/ethereum_test_forks/tests/test_forks.py

@@ -36,6 +36,9 @@
 )
 from ..helpers import (
     Fork,
+    ForkAdapter,
+    ForkOrNoneAdapter,
+    ForkSetAdapter,
     forks_from,
     forks_from_until,
     get_deployed_forks,
@@ -492,3 +495,15 @@ def test_bpo_fork():  # noqa: D103
     assert BPO1ToBPO2AtTime15k.bpo_fork() is True
     assert BPO2ToBPO3AtTime15k.bpo_fork() is True
     assert BPO3ToBPO4AtTime15k.bpo_fork() is True
+
+
+def test_fork_adapters():  # noqa: D103
+    assert Osaka == ForkAdapter.validate_python("Osaka")
+    assert Osaka == ForkOrNoneAdapter.validate_python("Osaka")
+    assert ForkOrNoneAdapter.validate_python(None) is None
+    assert {Osaka, Prague} == ForkSetAdapter.validate_python("Osaka, Prague")
+    assert {Osaka, Prague} == ForkSetAdapter.validate_python("osaka, Prague")
+    assert {Osaka, Prague} == ForkSetAdapter.validate_python({"osaka", "Prague"})
+    assert {Osaka} == ForkSetAdapter.validate_python("Osaka")
+    assert {Osaka} == ForkSetAdapter.validate_python({Osaka})
+    assert set() == ForkSetAdapter.validate_python("")

src/pytest_plugins/filler/static_filler.py

@@ -21,7 +21,7 @@
 from ethereum_test_specs import BaseStaticTest, BaseTest
 from ethereum_test_tools.code.yul import Yul
 
-from ..forks.forks import ValidityMarker, get_intersection_set
+from ..forks.forks import ValidityMarker
 from ..shared.helpers import labeled_format_parameter_set
 
 
@@ -189,19 +189,24 @@ def collect(self: "FillerFile") -> Generator["FillerTestItem", None, None]:
                                 if session.should_generate_format(fixture_format)
                             )
 
-                    validity_markers: List[ValidityMarker] = (
-                        ValidityMarker.get_all_validity_markers(key, self.config, function_marks)
+                    test_fork_set = ValidityMarker.get_test_fork_set_from_markers(
+                        iter(function_marks)
                     )
-                    intersection_set = get_intersection_set(key, validity_markers, self.config)
+                    if not test_fork_set:
+                        pytest.fail(
+                            "The test function's "
+                            f"'{key}' fork validity markers generate "
+                            "an empty fork range. Please check the arguments to its "
+                            f"markers:  @pytest.mark.valid_from and "
+                            f"@pytest.mark.valid_until."
+                        )
+                    intersection_set = test_fork_set & self.config.selected_fork_set  # type: ignore
 
                     extra_function_marks: List[pytest.Mark] = [
                         mark
                         for mark in function_marks
                         if mark.name != "parametrize"
-                        and (
-                            mark.name
-                            not in [v.mark.name for v in validity_markers if v.mark is not None]
-                        )
+                        and not ValidityMarker.is_validity_or_filter_marker(mark.name)
                     ]
 
                     for format_with_or_without_label in fixture_formats: