Remove usages of typing.Any when possible

Author: youtux

src/pytest_bdd/compat.py

@@ -2,7 +2,6 @@
 
 from collections.abc import Sequence
 from importlib.metadata import version
-from typing import Any
 
 from _pytest.fixtures import FixtureDef, FixtureManager, FixtureRequest
 from _pytest.nodes import Node
@@ -14,10 +13,12 @@
 
 if pytest_version.release >= (8, 1):
 
-    def getfixturedefs(fixturemanager: FixtureManager, fixturename: str, node: Node) -> Sequence[FixtureDef] | None:
+    def getfixturedefs(
+        fixturemanager: FixtureManager, fixturename: str, node: Node
+    ) -> Sequence[FixtureDef[object]] | None:
         return fixturemanager.getfixturedefs(fixturename, node)
 
-    def inject_fixture(request: FixtureRequest, arg: str, value: Any) -> None:
+    def inject_fixture(request: FixtureRequest, arg: str, value: object) -> None:
         """Inject fixture into pytest fixture request.
 
         :param request: pytest fixture request
@@ -38,10 +39,12 @@ def inject_fixture(request: FixtureRequest, arg: str, value: Any) -> None:
 
 else:
 
-    def getfixturedefs(fixturemanager: FixtureManager, fixturename: str, node: Node) -> Sequence[FixtureDef] | None:
+    def getfixturedefs(
+        fixturemanager: FixtureManager, fixturename: str, node: Node
+    ) -> Sequence[FixtureDef[object]] | None:
         return fixturemanager.getfixturedefs(fixturename, node.nodeid)  # type: ignore
 
-    def inject_fixture(request: FixtureRequest, arg: str, value: Any) -> None:
+    def inject_fixture(request: FixtureRequest, arg: str, value: object) -> None:
         """Inject fixture into pytest fixture request.
 
         :param request: pytest fixture request

src/pytest_bdd/cucumber_json.py

@@ -6,13 +6,13 @@
 import math
 import os
 import time
-import typing
+from typing import TYPE_CHECKING, Any, Literal, TypedDict
 
-from .reporting import test_report_context_registry
+from typing_extensions import NotRequired
 
-if typing.TYPE_CHECKING:
-    from typing import Any
+from .reporting import test_report_context_registry
 
+if TYPE_CHECKING:
     from _pytest.config import Config
     from _pytest.config.argparsing import Parser
     from _pytest.reports import TestReport
@@ -48,6 +48,12 @@ def unconfigure(config: Config) -> None:
         config.pluginmanager.unregister(xml)
 
 
+class Result(TypedDict):
+    status: Literal["passed", "failed", "skipped"]
+    duration: int  # in nanoseconds
+    error_message: NotRequired[str]
+
+
 class LogBDDCucumberJSON:
     """Logging plugin for cucumber like json output."""
 
@@ -56,22 +62,28 @@ def __init__(self, logfile: str) -> None:
         self.logfile = os.path.normpath(os.path.abspath(logfile))
         self.features: dict[str, dict] = {}
 
-    def _get_result(self, step: dict[str, Any], report: TestReport, error_message: bool = False) -> dict[str, Any]:
+    def _get_result(self, step: dict[str, Any], report: TestReport, error_message: bool = False) -> Result:
         """Get scenario test run result.
 
         :param step: `Step` step we get result for
         :param report: pytest `Report` object
         :return: `dict` in form {"status": "<passed|failed|skipped>", ["error_message": "<error_message>"]}
         """
-        result: dict[str, Any] = {}
-        if report.passed or not step["failed"]:  # ignore setup/teardown
-            result = {"status": "passed"}
-        elif report.failed:
-            result = {"status": "failed", "error_message": str(report.longrepr) if error_message else ""}
-        elif report.skipped:
-            result = {"status": "skipped"}
-        result["duration"] = int(math.floor((10**9) * step["duration"]))  # nanosec
-        return result
+        status: Literal["passed", "failed", "skipped"]
+        res_message = None
+        if report.outcome == "passed" or not step["failed"]:  # ignore setup/teardown
+            status = "passed"
+        elif report.outcome == "failed":
+            status = "failed"
+            res_message = str(report.longrepr) if error_message else ""
+        elif report.outcome == "skipped":
+            status = "skipped"
+        else:
+            raise ValueError(f"Unknown test outcome {report.outcome}")
+        res: Result = {"status": status, "duration": int(math.floor((10**9) * step["duration"]))}  # nanosec
+        if res_message is not None:
+            res["error_message"] = res_message
+        return res
 
     def _serialize_tags(self, item: dict[str, Any]) -> list[dict[str, Any]]:
         """Serialize item's tags.

src/pytest_bdd/generation.py

@@ -25,7 +25,6 @@
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
-    from typing import Any
 
     from _pytest.config import Config
     from _pytest.config.argparsing import Parser
@@ -133,22 +132,26 @@ def print_missing_code(scenarios: list[ScenarioTemplate], steps: list[Step]) ->
     tw.write(code)
 
 
-def _find_step_fixturedef(fixturemanager: FixtureManager, item: Node, step: Step) -> Sequence[FixtureDef[Any]] | None:
+def _find_step_fixturedef(
+    fixturemanager: FixtureManager, item: Node, step: Step
+) -> Sequence[FixtureDef[object]] | None:
     """Find step fixturedef."""
     with inject_fixturedefs_for_step(step=step, fixturemanager=fixturemanager, node=item):
         bdd_name = get_step_fixture_name(step=step)
         return getfixturedefs(fixturemanager, bdd_name, item)
 
 
-def parse_feature_files(paths: list[str], **kwargs: Any) -> tuple[list[Feature], list[ScenarioTemplate], list[Step]]:
+def parse_feature_files(
+    paths: list[str], encoding: str = "utf-8"
+) -> tuple[list[Feature], list[ScenarioTemplate], list[Step]]:
     """Parse feature files of given paths.
 
     :param paths: `list` of paths (file or dirs)
 
     :return: `list` of `tuple` in form:
              (`list` of `Feature` objects, `list` of `Scenario` objects, `list` of `Step` objects).
     """
-    features = get_features(paths, **kwargs)
+    features = get_features(paths, encoding=encoding)
     scenarios = sorted(
         itertools.chain.from_iterable(feature.scenarios.values() for feature in features),
         key=lambda scenario: (scenario.feature.name or scenario.feature.filename, scenario.name),

src/pytest_bdd/gherkin_terminal_reporter.py

@@ -7,8 +7,6 @@
 from .reporting import test_report_context_registry
 
 if typing.TYPE_CHECKING:
-    from typing import Any
-
     from _pytest.config import Config
     from _pytest.config.argparsing import Parser
     from _pytest.reports import TestReport
@@ -50,7 +48,7 @@ def __init__(self, config: Config) -> None:
         super().__init__(config)
         self.current_rule = None
 
-    def pytest_runtest_logreport(self, report: TestReport) -> Any:
+    def pytest_runtest_logreport(self, report: TestReport) -> None:
         rep = report
         res = self.config.hook.pytest_report_teststatus(report=rep, config=self.config)
         cat, letter, word = res
@@ -120,4 +118,3 @@ def pytest_runtest_logreport(self, report: TestReport) -> Any:
             self._tw.write("\n\n")
 
         self.stats.setdefault(cat, []).append(rep)
-        return None

src/pytest_bdd/parser.py

@@ -6,7 +6,6 @@
 from collections import OrderedDict
 from collections.abc import Generator, Iterable, Mapping, Sequence
 from dataclasses import dataclass, field
-from typing import Any
 
 from .exceptions import StepError
 from .gherkin_parser import Background as GherkinBackground
@@ -95,11 +94,11 @@ def add_example(self, values: Sequence[str]) -> None:
         """
         self.examples.append([str(value) if value is not None else "" for value in values])
 
-    def as_contexts(self) -> Iterable[dict[str, Any]]:
+    def as_contexts(self) -> Generator[dict[str, str]]:
         """Generate contexts for the examples.
 
         Yields:
-            Dict[str, Any]: A dictionary mapping parameter names to their values for each example row.
+            dict[str, str]: A dictionary mapping parameter names to their values for each example row.
         """
         for row in self.examples:
             assert len(self.example_params) == len(row)
@@ -180,11 +179,11 @@ def steps(self) -> list[Step]:
         """
         return self.all_background_steps + self._steps
 
-    def render(self, context: Mapping[str, Any]) -> Scenario:
+    def render(self, context: Mapping[str, object]) -> Scenario:
         """Render the scenario with the given context.
 
         Args:
-            context (Mapping[str, Any]): The context for rendering steps.
+            context (Mapping[str, object]): The context for rendering steps.
 
         Returns:
             Scenario: A Scenario object with steps rendered based on the context.
@@ -308,11 +307,11 @@ def params(self) -> tuple[str, ...]:
         """
         return tuple(frozenset(STEP_PARAM_RE.findall(self.name)))
 
-    def render(self, context: Mapping[str, Any]) -> str:
+    def render(self, context: Mapping[str, object]) -> str:
         """Render the step name with the given context, but avoid replacing text inside angle brackets if context is missing.
 
         Args:
-            context (Mapping[str, Any]): The context for rendering the step name.
+            context (Mapping[str, object]): The context for rendering the step name.
 
         Returns:
             str: The rendered step name with parameters replaced only if they exist in the context.

src/pytest_bdd/plugin.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import Generator
-from typing import TYPE_CHECKING, Any, Callable, TypeVar, cast
+from typing import TYPE_CHECKING, Callable, TypeVar, cast
 
 import pytest
 from typing_extensions import ParamSpec
@@ -99,8 +99,8 @@ def pytest_bdd_step_error(
     feature: Feature,
     scenario: Scenario,
     step: Step,
-    step_func: Callable[..., Any],
-    step_func_args: dict,
+    step_func: Callable[..., object],
+    step_func_args: dict[str, object],
     exception: Exception,
 ) -> None:
     reporting.step_error(request, feature, scenario, step, step_func, step_func_args, exception)
@@ -112,7 +112,7 @@ def pytest_bdd_before_step(
     feature: Feature,
     scenario: Scenario,
     step: Step,
-    step_func: Callable[..., Any],
+    step_func: Callable[..., object],
 ) -> None:
     reporting.before_step(request, feature, scenario, step, step_func)
 
@@ -123,8 +123,8 @@ def pytest_bdd_after_step(
     feature: Feature,
     scenario: Scenario,
     step: Step,
-    step_func: Callable[..., Any],
-    step_func_args: dict[str, Any],
+    step_func: Callable[..., object],
+    step_func_args: dict[str, object],
 ) -> None:
     reporting.after_step(request, feature, scenario, step, step_func, step_func_args)
 

src/pytest_bdd/reporting.py

@@ -39,7 +39,7 @@ def __init__(self, step: Step) -> None:
         self.step = step
         self.started = time.perf_counter()
 
-    def serialize(self) -> dict[str, Any]:
+    def serialize(self) -> dict[str, object]:
         """Serialize the step execution report.
 
         :return: Serialized step execution report.
@@ -103,7 +103,7 @@ def add_step_report(self, step_report: StepReport) -> None:
         """
         self.step_reports.append(step_report)
 
-    def serialize(self) -> dict[str, Any]:
+    def serialize(self) -> dict[str, object]:
         """Serialize scenario execution report in order to transfer reporting from nodes in the distributed mode.
 
         :return: Serialized report.
@@ -178,8 +178,8 @@ def step_error(
     feature: Feature,
     scenario: Scenario,
     step: Step,
-    step_func: Callable[..., Any],
-    step_func_args: dict,
+    step_func: Callable[..., object],
+    step_func_args: dict[str, object],
     exception: Exception,
 ) -> None:
     """Finalize the step report as failed."""

src/pytest_bdd/scenario.py

@@ -44,10 +44,10 @@
 PYTHON_REPLACE_REGEX = re.compile(r"\W")
 ALPHA_REGEX = re.compile(r"^\d+_*")
 
-scenario_wrapper_template_registry: WeakKeyDictionary[Callable[..., Any], ScenarioTemplate] = WeakKeyDictionary()
+scenario_wrapper_template_registry: WeakKeyDictionary[Callable[..., object], ScenarioTemplate] = WeakKeyDictionary()
 
 
-def find_fixturedefs_for_step(step: Step, fixturemanager: FixtureManager, node: Node) -> Iterable[FixtureDef[Any]]:
+def find_fixturedefs_for_step(step: Step, fixturemanager: FixtureManager, node: Node) -> Iterable[FixtureDef[object]]:
     """Find the fixture defs that can parse a step."""
     # happens to be that _arg2fixturedefs is changed during the iteration so we use a copy
     fixture_def_by_name = list(fixturemanager._arg2fixturedefs.items())
@@ -64,7 +64,7 @@ def find_fixturedefs_for_step(step: Step, fixturemanager: FixtureManager, node:
             if not match:
                 continue
 
-            fixturedefs = cast(list[FixtureDef[Any]], getfixturedefs(fixturemanager, fixturename, node) or [])
+            fixturedefs = list(getfixturedefs(fixturemanager, fixturename, node) or [])
             if fixturedef not in fixturedefs:
                 continue
 

src/pytest_bdd/steps.py

@@ -41,7 +41,7 @@ def _(article):
 from collections.abc import Iterable
 from dataclasses import dataclass, field
 from itertools import count
-from typing import Any, Callable, Literal, TypeVar
+from typing import Callable, Literal, TypeVar
 from weakref import WeakKeyDictionary
 
 import pytest
@@ -54,7 +54,7 @@ def _(article):
 P = ParamSpec("P")
 T = TypeVar("T")
 
-step_function_context_registry: WeakKeyDictionary[Callable[..., Any], StepFunctionContext] = WeakKeyDictionary()
+step_function_context_registry: WeakKeyDictionary[Callable[..., object], StepFunctionContext] = WeakKeyDictionary()
 
 
 @enum.unique
@@ -66,9 +66,9 @@ class StepNamePrefix(enum.Enum):
 @dataclass
 class StepFunctionContext:
     type: Literal["given", "when", "then"] | None
-    step_func: Callable[..., Any]
+    step_func: Callable[..., object]
     parser: StepParser
-    converters: dict[str, Callable[[str], Any]] = field(default_factory=dict)
+    converters: dict[str, Callable[[str], object]] = field(default_factory=dict)
     target_fixture: str | None = None
 
 
@@ -79,7 +79,7 @@ def get_step_fixture_name(step: Step) -> str:
 
 def given(
     name: str | StepParser,
-    converters: dict[str, Callable[[str], Any]] | None = None,
+    converters: dict[str, Callable[[str], object]] | None = None,
     target_fixture: str | None = None,
     stacklevel: int = 1,
 ) -> Callable[[Callable[P, T]], Callable[P, T]]:
@@ -98,7 +98,7 @@ def given(
 
 def when(
     name: str | StepParser,
-    converters: dict[str, Callable[[str], Any]] | None = None,
+    converters: dict[str, Callable[[str], object]] | None = None,
     target_fixture: str | None = None,
     stacklevel: int = 1,
 ) -> Callable[[Callable[P, T]], Callable[P, T]]:
@@ -117,7 +117,7 @@ def when(
 
 def then(
     name: str | StepParser,
-    converters: dict[str, Callable[[str], Any]] | None = None,
+    converters: dict[str, Callable[[str], object]] | None = None,
     target_fixture: str | None = None,
     stacklevel: int = 1,
 ) -> Callable[[Callable[P, T]], Callable[P, T]]:
@@ -137,7 +137,7 @@ def then(
 def step(
     name: str | StepParser,
     type_: Literal["given", "when", "then"] | None = None,
-    converters: dict[str, Callable[[str], Any]] | None = None,
+    converters: dict[str, Callable[[str], object]] | None = None,
     target_fixture: str | None = None,
     stacklevel: int = 1,
 ) -> Callable[[Callable[P, T]], Callable[P, T]]: