refs(search): Add some typing to event_search.py, and refactor convert_search_filter_to_snuba_query to be less huge (#26190)

This should be functionally the same as before, just breaking up
`convert_search_filter_to_snuba_query` some.

Author: wedamija

src/sentry/api/event_search.py

@@ -1,6 +1,7 @@
 import re
 from collections import namedtuple
 from datetime import datetime
+from typing import NamedTuple, Sequence, Union
 
 from django.utils.functional import cached_property
 from parsimonious.exceptions import IncompleteParseError
@@ -138,7 +139,7 @@
 )
 
 
-def translate(pat):
+def translate(pat) -> str:
     """Translate a shell PATTERN to a regular expression.
     modified from: https://github.com/python/cpython/blob/2.7/Lib/fnmatch.py#L85
     """
@@ -176,70 +177,42 @@ class ParenExpression(namedtuple("ParenExpression", "children")):
     pass
 
 
-class SearchFilter(namedtuple("SearchFilter", "key operator value")):
-    def __str__(self):
-        return "".join(map(str, (self.key.name, self.operator, self.value.raw_value)))
-
-    @cached_property
-    def is_negation(self):
-        # Negations are mostly just using != operators. But we also have
-        # negations on has: filters, which translate to = '', so handle that
-        # case as well.
-        return (
-            self.operator == "!="
-            and self.value.raw_value != ""
-            or self.operator == "="
-            and self.value.raw_value == ""
-            or self.operator == "NOT IN"
-            and self.value.raw_value
-        )
+class SearchKey(NamedTuple):
+    name: str
 
-    @cached_property
-    def is_in_filter(self):
-        return self.operator in ("IN", "NOT IN")
-
-
-class SearchKey(namedtuple("SearchKey", "name")):
-    @cached_property
-    def is_tag(self):
+    @property
+    def is_tag(self) -> bool:
         return TAG_KEY_RE.match(self.name) or (
             self.name not in SEARCH_MAP
             and self.name not in FIELD_ALIASES
             and not self.is_measurement
             and not self.is_span_op_breakdown
         )
 
-    @cached_property
-    def is_measurement(self):
+    @property
+    def is_measurement(self) -> bool:
         return is_measurement(self.name) and self.name not in SEARCH_MAP
 
-    @cached_property
-    def is_span_op_breakdown(self):
+    @property
+    def is_span_op_breakdown(self) -> bool:
         return is_span_op_breakdown(self.name) and self.name not in SEARCH_MAP
 
 
-class AggregateFilter(namedtuple("AggregateFilter", "key operator value")):
-    def __str__(self):
-        return "".join(map(str, (self.key.name, self.operator, self.value.raw_value)))
-
-
-class AggregateKey(namedtuple("AggregateKey", "name")):
-    pass
+class SearchValue(NamedTuple):
+    raw_value: Union[str, int, datetime, Sequence[int], Sequence[str]]
 
-
-class SearchValue(namedtuple("SearchValue", "raw_value")):
     @property
     def value(self):
         if self.is_wildcard():
             return translate(self.raw_value)
         return self.raw_value
 
-    def is_wildcard(self):
+    def is_wildcard(self) -> bool:
         if not isinstance(self.raw_value, str):
             return False
         return bool(WILDCARD_CHARS.search(self.raw_value))
 
-    def is_event_id(self):
+    def is_event_id(self) -> bool:
         """Return whether the current value is a valid event id
 
         Empty strings are valid, so that it can be used for has:id queries
@@ -249,6 +222,46 @@ def is_event_id(self):
         return is_event_id(self.raw_value) or self.raw_value == ""
 
 
+class SearchFilter(NamedTuple):
+    key: SearchKey
+    operator: str
+    value: SearchValue
+
+    def __str__(self):
+        return "".join(map(str, (self.key.name, self.operator, self.value.raw_value)))
+
+    @property
+    def is_negation(self) -> bool:
+        # Negations are mostly just using != operators. But we also have
+        # negations on has: filters, which translate to = '', so handle that
+        # case as well.
+        return (
+            self.operator == "!="
+            and self.value.raw_value != ""
+            or self.operator == "="
+            and self.value.raw_value == ""
+            or self.operator == "NOT IN"
+            and self.value.raw_value
+        )
+
+    @property
+    def is_in_filter(self) -> bool:
+        return self.operator in ("IN", "NOT IN")
+
+
+class AggregateFilter(NamedTuple):
+    key: SearchKey
+    operator: str
+    value: SearchValue
+
+    def __str__(self):
+        return "".join(map(str, (self.key.name, self.operator, self.value.raw_value)))
+
+
+class AggregateKey(NamedTuple):
+    name: str
+
+
 class SearchVisitor(NodeVisitor):
     # A list of mappers that map source keys to a target name. Format is
     # <target_name>: [<list of source names>],