fix(tools): fix remaining lint checks after large ruff refactor (ethereum#2050)

Author: fselmo

packages/testing/src/execution_testing/fixtures/base.py

@@ -33,7 +33,8 @@ def fixture_format_discriminator(v: Any) -> str | None:
         info_dict = v.info
     if info_dict is None:
         raise ValueError(
-            f"Fixture does not have an info field, cannot determine fixture format: {v}"
+            "Fixture does not have an info field, "
+            f"cannot determine fixture format: {v}"
         )
     fixture_format = info_dict.get("fixture-format")
     if not fixture_format:

packages/testing/src/execution_testing/fixtures/blockchain.py

@@ -97,11 +97,13 @@ def validate_post_state_fields(self: Any) -> Any:
 
                 if field1_value is None and field2_value is None:
                     raise ValueError(
-                        f"Either {field1_name} or {field2_name} must be provided."
+                        f"Either {field1_name} or {field2_name} "
+                        "must be provided."
                     )
                 if field1_value is not None and field2_value is not None:
                     raise ValueError(
-                        f"Only one of {field1_name} or {field2_name} must be provided."
+                        f"Only one of {field1_name} or {field2_name} "
+                        "must be provided."
                     )
             return self
 
@@ -145,8 +147,8 @@ class FixtureHeader(CamelModel):
     We combine the `Environment` and `Result` contents to create this model.
     """
 
-    # Allow extra fields: FixtureHeader is constructed from merged Result and
-    # Environment data via model_dump(), which includes fields not in this model.
+    # Allow extra fields: FixtureHeader is constructed from merged Result
+    # and Environment data via model_dump(), which has extra fields.
     model_config = CamelModel.model_config | {"extra": "ignore"}
 
     parent_hash: Hash = Hash(0)
@@ -286,42 +288,51 @@ def get_default_from_annotation(
         timestamp: int = 0,
     ) -> Any:
         """
-        Get appropriate default value for a header field based on its type hint.
+        Get default value for a header field based on its type hint.
 
         This method handles:
-        1. Fork requirement checking - only returns a default if the fork requires the field
+        1. Fork requirement checking - only returns a default if the fork
+           requires the field
         2. Model-defined defaults - uses the field's default value if available
         3. Type-based defaults - constructs defaults based on the field type
 
         Args:
             fork: Fork to check requirements against
             field_name: Name of the field
             field_hint: Type annotation of the field
-            block_number: Block number for fork requirement checking (default: 0)
+            block_number: Block number for fork requirement checking
+                (default: 0)
             timestamp: Timestamp for fork requirement checking (default: 0)
 
         Returns:
             Default value appropriate for the field type, or None if
             the field is not required by the fork
 
         Raises:
-            TypeError: If the field type is not supported and no default value
-                is defined in the model. This indicates that support for the type
-                needs to be added or an explicit default must be provided.
+            TypeError: If the field type is not supported and no default
+                value is defined in the model. This indicates that support
+                for the type needs to be added or an explicit default must
+                be provided.
+
         """
         # Check if this field has a HeaderForkRequirement annotation
         header_fork_requirement = HeaderForkRequirement.get_from_annotation(
             field_hint
         )
         if header_fork_requirement is not None:
             # Only provide a default if the fork requires this field
-            if not header_fork_requirement.required(fork, block_number, timestamp):
+            if not header_fork_requirement.required(
+                fork, block_number, timestamp
+            ):
                 return None
 
         # Check if the field has a default value defined in the model
         if field_name in cls.model_fields:
             field_info = cls.model_fields[field_name]
-            if field_info.default is not None and field_info.default is not PydanticUndefined:
+            if (
+                field_info.default is not None
+                and field_info.default is not PydanticUndefined
+            ):
                 return field_info.default
             if field_info.default_factory is not None:
                 return field_info.default_factory()  # type: ignore[call-arg]
@@ -339,11 +350,11 @@ def get_default_from_annotation(
         elif actual_type == Bytes:
             return Bytes(b"")
         else:
-            # Unsupported type - raise an error to catch this during development
+            # Unsupported type - raise error to catch this during development
             raise TypeError(
                 f"Cannot generate default value for field '{field_name}' "
                 f"with unsupported type '{actual_type}'. "
-                f"Add support for this type or provide a default value explicitly."
+                "Add support for this type or provide a default explicitly."
             )
 
     @classmethod
@@ -501,7 +512,8 @@ def from_fixture_header(
         ):
             if block_access_list is None:
                 raise ValueError(
-                    f"`block_access_list` is required in engine `ExecutionPayload` for >={fork}."
+                    "`block_access_list` is required in engine "
+                    f"`ExecutionPayload` for >={fork}."
                 )
 
         execution_payload = FixtureExecutionPayload.from_fixture_header(
@@ -609,8 +621,9 @@ class FixtureBlockBase(CamelModel):
     @classmethod
     def strip_block_number_computed_field(cls, data: Any) -> Any:
         """
-        Strip the block_number computed field which gets included in model_dump()
-        but is not a valid input field.
+        Strip the block_number computed field included in model_dump().
+
+        This field is not a valid input field.
         """
         if isinstance(data, dict):
             data.pop("blocknumber", None)
@@ -785,7 +798,7 @@ class BlockchainEngineXFixture(BlockchainEngineFixtureCommon):
     """
 
     # Allow extra fields: BlockchainEngineXFixture is constructed from shared
-    # fixture_data that includes fields for other fixture formats (e.g. genesis).
+    # fixture_data that has fields for other fixture formats (e.g. genesis).
     model_config = CamelModel.model_config | {"extra": "ignore"}
 
     format_name: ClassVar[str] = "blockchain_test_engine_x"
@@ -824,7 +837,8 @@ class BlockchainEngineSyncFixture(BlockchainEngineFixture):
 
     format_name: ClassVar[str] = "blockchain_test_sync"
     description: ClassVar[str] = (
-        "Tests that generate a blockchain test fixture for Engine API testing with client sync."
+        "Tests that generate a blockchain test fixture for Engine API "
+        "testing with client sync."
     )
     sync_payload: FixtureEngineNewPayload | None = None
 

packages/testing/src/execution_testing/fixtures/collector.py

@@ -84,7 +84,8 @@ def get_dump_dir_path(
                 str(test_module_relative_dir).replace(os.sep, "__")
             )
         test_name, test_parameter_string = self.get_name_and_parameters()
-        flat_path = f"{str(test_module_relative_dir).replace(os.sep, '__')}__{test_name}"
+        dir_str = str(test_module_relative_dir).replace(os.sep, "__")
+        flat_path = f"{dir_str}__{test_name}"
         if level == "test_function":
             return Path(base_dump_dir) / flat_path
         elif level == "test_parameter":

packages/testing/src/execution_testing/fixtures/common.py

@@ -52,7 +52,7 @@ class FixtureAuthorizationTuple(
     """Authorization tuple for fixture transactions."""
 
     # Allow extra fields: FixtureAuthorizationTuple is constructed from
-    # AuthorizationTuple via model_dump(), which includes fields not in this model.
+    # AuthorizationTuple via model_dump(), which has extra fields.
     model_config = CamelModel.model_config | {"extra": "ignore"}
 
     v: ZeroPaddedHexNumber = Field(

packages/testing/src/execution_testing/fixtures/pre_alloc_groups.py

@@ -178,7 +178,7 @@ class ModelDumpCache:
     model_dump_mode: Literal["json", "python"]
     """Mode of the model dump when `model_dump` is called."""
     model_dump_type: Literal["string", "dict"]
-    """Whether `model_dump_json` or `model_dump` was used to generate the data."""
+    """Whether `model_dump_json` or `model_dump` was used to generate data."""
     data: Any
 
 
@@ -197,7 +197,7 @@ class GroupPreAlloc(Alloc):
     _model_dump_cache: ModelDumpCache | None = PrivateAttr(None)
 
     def state_root(self) -> Hash:
-        """On pre-alloc groups, which are normally very big, we always cache."""
+        """On pre-alloc groups, which are normally very big, always cache."""
         if self._cached_state_root is not None:
             return self._cached_state_root
         return super().state_root()
@@ -230,7 +230,7 @@ def model_dump(  # type: ignore[override]
         return data
 
     def model_dump_json(self, **kwargs: Any) -> str:
-        """Model dump the pre-allocation group in JSON string format, with caching."""
+        """Model dump the pre-allocation group in JSON string, with caching."""
         if (
             self._model_dump_cache is not None
             and self._model_dump_cache.model_dump_mode == "json"