add types to enhancements modules

Author: lobsterkatie

src/sentry/grouping/enhancer/__init__.py

@@ -145,7 +145,12 @@ class Enhancements:
     # See ``GroupingConfigLoader._get_enhancements`` in src/sentry/grouping/api.py.
 
     def __init__(
-        self, rules, rust_enhancements: RustEnhancements, version=None, bases=None, id=None
+        self,
+        rules: list[EnhancementRule],
+        rust_enhancements: RustEnhancements,
+        version: int | None = None,
+        bases: list[str] | None = None,
+        id: str | None = None,
     ):
         self.id = id
         self.rules = rules
@@ -286,8 +291,8 @@ def assemble_stacktrace_component(
 
         return stacktrace_component
 
-    def as_dict(self, with_rules=False):
-        rv = {
+    def as_dict(self, with_rules: bool = False) -> EnhancementsDict:
+        rv: EnhancementsDict = {
             "id": self.id,
             "bases": self.bases,
             "latest": projectoptions.lookup_well_known_key(
@@ -299,7 +304,8 @@ def as_dict(self, with_rules=False):
             rv["rules"] = [x.as_dict() for x in self.rules]
         return rv
 
-    def _to_config_structure(self):
+    def _to_config_structure(self) -> list[Any]:
+        # TODO: Can we switch this to a tuple so we can type it more exactly?
         return [
             self.version,
             self.bases,
@@ -312,7 +318,11 @@ def dumps(self) -> str:
         return base64.urlsafe_b64encode(compressed).decode("ascii").strip("=")
 
     @classmethod
-    def _from_config_structure(cls, data, rust_enhancements: RustEnhancements) -> Enhancements:
+    def _from_config_structure(
+        cls,
+        data: list[Any],
+        rust_enhancements: RustEnhancements,
+    ) -> Enhancements:
         version, bases, rules = data
         if version not in VERSIONS:
             raise ValueError("Unknown version")
@@ -324,7 +334,7 @@ def _from_config_structure(cls, data, rust_enhancements: RustEnhancements) -> En
         )
 
     @classmethod
-    def loads(cls, data) -> Enhancements:
+    def loads(cls, data: str | bytes) -> Enhancements:
         if isinstance(data, str):
             data = data.encode("ascii", "ignore")
         padded = data + b"=" * (4 - (len(data) % 4))
@@ -344,7 +354,9 @@ def loads(cls, data) -> Enhancements:
 
     @classmethod
     @sentry_sdk.tracing.trace
-    def from_config_string(cls, s, bases=None, id=None) -> Enhancements:
+    def from_config_string(
+        cls, s: str, bases: list[str] | None = None, id: str | None = None
+    ) -> Enhancements:
         rust_enhancements = parse_rust_enhancements("config_string", s)
 
         rules = parse_enhancements(s)

src/sentry/grouping/enhancer/actions.py

@@ -1,12 +1,17 @@
 from __future__ import annotations
 
 from collections.abc import Callable, Sequence
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
+from sentry.grouping.component import BaseGroupingComponent
+from sentry.grouping.enhancer.matchers import MatchFrame
 from sentry.utils.safe import get_path, set_path
 
 from .exceptions import InvalidEnhancerConfig
 
+if TYPE_CHECKING:
+    from sentry.grouping.enhancer.rules import EnhancementRule
+
 ACTIONS = ["group", "app"]
 ACTION_BITSIZE = 8
 # Ensure that the number of possible actions is smaller than the number of numbers which can be
@@ -30,14 +35,18 @@ class EnhancementAction:
     def apply_modifications_to_frame(
         self,
         frames: Sequence[dict[str, Any]],
-        match_frames: Sequence[dict[str, Any]],
+        match_frames: list[MatchFrame],
         idx: int,
-        rule: Any = None,
+        rule: Any | None = None,
     ) -> None:
         pass
 
     def update_frame_components_contributions(
-        self, components, frames: Sequence[dict[str, Any]], idx, rule=None
+        self,
+        components: list[BaseGroupingComponent],
+        frames: list[dict[str, Any]],
+        idx: int,
+        rule: Any | None = None,
     ) -> None:
         pass
 
@@ -55,7 +64,7 @@ def is_updater(self) -> bool:
         return self._is_updater
 
     @classmethod
-    def _from_config_structure(cls, val, version: int):
+    def _from_config_structure(cls, val: list[str] | int, version: int) -> EnhancementAction:
         if isinstance(val, list):  # This is a `VarAction`
             variable, value = val
             return VarAction(variable, value)
@@ -88,7 +97,7 @@ def __str__(self) -> str:
             self.key,
         )
 
-    def _to_config_structure(self, version: int):
+    def _to_config_structure(self, version: int) -> int:
         """
         Convert the action into an integer by
             - converting the combination of its boolean value (if it's a `+app/+group` rule or a
@@ -100,7 +109,7 @@ def _to_config_structure(self, version: int):
         """
         return ACTIONS.index(self.key) | (ACTION_FLAGS[self.flag, self.range] << ACTION_BITSIZE)
 
-    def _slice_to_range(self, seq, idx):
+    def _slice_to_range(self, seq: list[Any], idx: int) -> list[Any]:
         if self.range is None:
             return [seq[idx]]
         elif self.range == "down":
@@ -122,17 +131,21 @@ def _in_app_changed(self, frame: dict[str, Any]) -> bool:
     def apply_modifications_to_frame(
         self,
         frames: Sequence[dict[str, Any]],
-        match_frames: Sequence[dict[str, Any]],
+        match_frames: list[MatchFrame],
         idx: int,
-        rule: Any = None,
+        rule: Any | None = None,
     ) -> None:
         # Change a frame or many to be in_app
         if self.key == "app":
             for match_frame in self._slice_to_range(match_frames, idx):
                 match_frame["in_app"] = self.flag
 
     def update_frame_components_contributions(
-        self, components, frames: Sequence[dict[str, Any]], idx, rule=None
+        self,
+        components: list[BaseGroupingComponent],
+        frames: list[dict[str, Any]],
+        idx: int,
+        rule: EnhancementRule | None = None,
     ) -> None:
         rule_hint = "stack trace rule"
         if rule:
@@ -184,19 +197,20 @@ def __init__(self, var: str, value: str) -> None:
     def __str__(self) -> str:
         return f"{self.var}={self.value}"
 
-    def _to_config_structure(self, version):
+    def _to_config_structure(self, version: int) -> list[str | int]:
+        # TODO: Can we switch this to a tuple so we can type it more exactly?
         return [self.var, self.value]
 
-    def modify_stacktrace_state(self, state, rule):
+    def modify_stacktrace_state(self, state, rule) -> None:
         if self.var not in VarAction._FRAME_VARIABLES:
             state.set(self.var, self.value, rule)
 
     def apply_modifications_to_frame(
         self,
         frames: Sequence[dict[str, Any]],
-        match_frames: Sequence[dict[str, Any]],
+        match_frames: list[MatchFrame],
         idx: int,
-        rule: Any = None,
+        rule: Any | None = None,
     ) -> None:
         if self.var == "category":
             frame = frames[idx]