ref: fix remaining [index] mypy errors (#87597)

<!-- Describe your PR here. -->

Author: asottile-sentry

pyproject.toml

@@ -190,7 +190,6 @@ disable_error_code = [
     "assignment",
     "attr-defined",
     "call-overload",
-    "index",
     "misc",
     "operator",
     "override",

src/sentry/api/endpoints/organization_releases.py

@@ -88,21 +88,20 @@ def _filter_releases_by_query(queryset, organization, query, filter_params):
 
         if search_filter.key.name == RELEASE_ALIAS:
             query_q = Q()
-            raw_value = search_filter.value.raw_value
-            if search_filter.value.is_wildcard():
-                if raw_value.endswith("*") and raw_value.startswith("*"):
-                    query_q = Q(version__contains=raw_value[1:-1])
-                elif raw_value.endswith("*"):
-                    query_q = Q(version__startswith=raw_value[:-1])
-                elif raw_value.startswith("*"):
-                    query_q = Q(version__endswith=raw_value[1:])
+            kind, value_o = search_filter.value.classify_and_format_wildcard()
+            if kind == "infix":
+                query_q = Q(version__contains=value_o)
+            elif kind == "suffix":
+                query_q = Q(version__endswith=value_o)
+            elif kind == "prefix":
+                query_q = Q(version__startswith=value_o)
             elif search_filter.operator == "!=":
-                query_q = ~Q(version=search_filter.value.value)
+                query_q = ~Q(version=value_o)
             elif search_filter.operator == "NOT IN":
-                query_q = ~Q(version__in=raw_value)
+                query_q = ~Q(version__in=value_o)
             elif search_filter.operator == "IN":
-                query_q = Q(version__in=raw_value)
-            elif raw_value == "latest":
+                query_q = Q(version__in=value_o)
+            elif value_o == "latest":
                 latest_releases = get_latest_release(
                     projects=filter_params["project_id"],
                     environments=filter_params.get("environment"),

src/sentry/api/paginator.py

@@ -616,7 +616,7 @@ def __init__(self, intermediaries, desc=False, on_results=None, case_insensitive
             ), "When sorting by a date, it must be the key used on all intermediaries"
 
     def key_from_item(self, item):
-        return self.model_key_map.get(type(item))[0]
+        return self.model_key_map[type(item)][0]
 
     def _prep_value(self, item, key, for_prev):
         """
@@ -664,10 +664,10 @@ def _build_combined_querysets(self, is_prev):
         def _sort_combined_querysets(item):
             sort_keys = []
             sort_keys.append(self.get_item_key(item))
-            if len(self.model_key_map.get(type(item))) > 1:
+            if len(self.model_key_map[type(item)]) > 1:
                 # XXX: This doesn't do anything - it just uses a column name as the sort key. It should be pulling the
                 # value of the other keys out instead.
-                sort_keys.extend(iter(self.model_key_map.get(type(item))[1:]))
+                sort_keys.extend(iter(self.model_key_map[type(item)][1:]))
             sort_keys.append(type(item).__name__)
             return tuple(sort_keys)
 

src/sentry/integrations/gitlab/issues.py

@@ -22,6 +22,7 @@ def make_external_key(self, data):
 
     def get_issue_url(self, key: str) -> str:
         match = ISSUE_EXTERNAL_KEY_FORMAT.match(key)
+        assert match is not None
         project, issue_id = match.group(1), match.group(2)
         return "{}/{}/issues/{}".format(self.model.metadata["base_url"], project, issue_id)
 
@@ -34,10 +35,10 @@ def get_projects_and_default(self, group: Group, params: Mapping[str, Any], **kw
         # XXX: In GitLab repositories are called projects but get_repository_choices
         # expects the param to be called 'repo', so we need to rename it here.
         # Django QueryDicts are immutable, so we need to copy it first.
-        params = params.copy()
-        params["repo"] = params.get("project") or defaults.get("project")
+        params_mut = dict(params)
+        params_mut["repo"] = params.get("project") or defaults.get("project")
 
-        default_project, project_choices = self.get_repository_choices(group, params, **kwargs)
+        default_project, project_choices = self.get_repository_choices(group, params_mut, **kwargs)
         return default_project, project_choices
 
     def create_default_repo_choice(self, default_repo):

src/sentry/search/events/builder/base.py

@@ -222,7 +222,7 @@ def __init__(
         self.raw_equations = equations
         self.raw_orderby = orderby
         self.query = query
-        self.selected_columns = selected_columns
+        self.selected_columns = selected_columns or []
         self.groupby_columns = groupby_columns
         self.tips: dict[str, set[str]] = {
             "query": set(),

src/sentry/search/events/builder/metrics.py

@@ -262,9 +262,9 @@ def use_on_demand(self) -> bool:
         return bool(self._on_demand_metric_spec_map)
 
     @cached_property
-    def _on_demand_metric_spec_map(self) -> dict[str, OnDemandMetricSpec] | None:
+    def _on_demand_metric_spec_map(self) -> dict[str, OnDemandMetricSpec]:
         if not self.builder_config.on_demand_metrics_enabled:
-            return None
+            return {}
 
         spec_map = {}
         for col in self.selected_columns:
@@ -1970,9 +1970,9 @@ def translated_groupby(self) -> list[str]:
         return sorted(translated)
 
     @cached_property
-    def _on_demand_metric_spec_map(self) -> dict[str, OnDemandMetricSpec] | None:
+    def _on_demand_metric_spec_map(self) -> dict[str, OnDemandMetricSpec]:
         if not self.builder_config.on_demand_metrics_enabled:
-            return None
+            return {}
 
         return {
             col: self._get_on_demand_metric_spec(col)

src/sentry/search/snuba/executors.py

@@ -1569,20 +1569,15 @@ def get_first_release_condition(
                 organization=projects[0].organization_id, version__in=versions
             ).values_list("version", "id")
         }
-
-        for version in versions:
-            if version not in releases:
-                # TODO: This is mostly around for legacy reasons - we should probably just
-                # raise a validation here an inform the user that they passed an invalid
-                # release
-                releases[None] = -1
-                # We only need to find the first non-existent release here
-                break
+        # TODO: This is mostly around for legacy reasons - we should probably just
+        # raise a validation here an inform the user that they passed an invalid
+        # release
+        condition_values = list(releases.values())
+        if any(version not in releases for version in versions):
+            condition_values.append(-1)
 
         return Condition(
-            Column("group_first_release", self.entities["attrs"]),
-            Op.IN,
-            list(releases.values()),
+            Column("group_first_release", self.entities["attrs"]), Op.IN, condition_values
         )
 
     ISSUE_FIELD_NAME = "group_id"

src/sentry/snuba/metrics/query.py

@@ -40,7 +40,7 @@ class MetricField:
     op: MetricOperationType | None
     metric_mri: str
     params: dict[str, None | str | int | float | Sequence[tuple[str | int, ...]]] | None = None
-    alias: str | None = None
+    alias: str = ""
 
     def __post_init__(self) -> None:
         # Validate that it is a valid MRI format
@@ -87,7 +87,7 @@ class MetricActionByField:
 
 @dataclass(frozen=True)
 class MetricGroupByField(MetricActionByField):
-    alias: str | None = None
+    alias: str = ""
 
     def __post_init__(self) -> None:
         if not self.alias:

src/sentry/snuba/metrics/query_builder.py

@@ -1099,10 +1099,10 @@ def __generate_time_groupby_column_for_discover_queries(interval: int) -> Functi
     def __update_query_dicts_with_component_entities(
         self,
         component_entities: dict[MetricEntity, Sequence[str]],
-        metric_mri_to_obj_dict: dict[tuple[str | None, str, str | None], MetricExpressionBase],
-        fields_in_entities: dict[MetricEntity, list[tuple[str | None, str, str | None]]],
+        metric_mri_to_obj_dict: dict[tuple[str | None, str, str], MetricExpressionBase],
+        fields_in_entities: dict[MetricEntity, list[tuple[str | None, str, str]]],
         parent_alias,
-    ) -> dict[tuple[str | None, str, str | None], MetricExpressionBase]:
+    ) -> dict[tuple[str | None, str, str], MetricExpressionBase]:
         # At this point in time, we are only supporting raw metrics in the metrics attribute of
         # any instance of DerivedMetric, and so in this case the op will always be None
         # ToDo(ahmed): In future PR, we might want to allow for dependency metrics to also have an
@@ -1127,11 +1127,11 @@ def __update_query_dicts_with_component_entities(
         return metric_mri_to_obj_dict
 
     def get_snuba_queries(self):
-        metric_mri_to_obj_dict: dict[tuple[str | None, str, str | None], MetricExpressionBase] = {}
-        fields_in_entities: dict[MetricEntity, list[tuple[str | None, str, str | None]]] = {}
+        metric_mri_to_obj_dict: dict[tuple[str | None, str, str], MetricExpressionBase] = {}
+        fields_in_entities: dict[MetricEntity, list[tuple[str | None, str, str]]] = {}
 
-        for field in self._metrics_query.select:
-            metric_field_obj = metric_object_factory(field.op, field.metric_mri)
+        for select_field in self._metrics_query.select:
+            metric_field_obj = metric_object_factory(select_field.op, select_field.metric_mri)
             # `get_entity` is called the first, to fetch the entities of constituent metrics,
             # and validate especially in the case of SingularEntityDerivedMetric that it is
             # actually composed of metrics that belong to the same entity
@@ -1155,7 +1155,7 @@ def get_snuba_queries(self):
                         component_entities=component_entities,
                         metric_mri_to_obj_dict=metric_mri_to_obj_dict,
                         fields_in_entities=fields_in_entities,
-                        parent_alias=field.alias,
+                        parent_alias=select_field.alias,
                     )
                     continue
                 elif isinstance(component_entities, str):
@@ -1172,9 +1172,11 @@ def get_snuba_queries(self):
             if entity not in self._implemented_datasets:
                 raise NotImplementedError(f"Dataset not yet implemented: {entity}")
 
-            metric_mri_to_obj_dict[(field.op, field.metric_mri, field.alias)] = metric_field_obj
+            metric_mri_to_obj_dict[
+                (select_field.op, select_field.metric_mri, select_field.alias)
+            ] = metric_field_obj
             fields_in_entities.setdefault(entity, []).append(
-                (field.op, field.metric_mri, field.alias)
+                (select_field.op, select_field.metric_mri, select_field.alias)
             )
 
         where = self._build_where()
@@ -1252,7 +1254,7 @@ def __init__(
         self,
         organization_id: int,
         metrics_query: DeprecatingMetricsQuery,
-        fields_in_entities: dict,
+        fields_in_entities: dict[MetricEntity, list[tuple[str | None, str, str]]],
         intervals: list[datetime],
         results,
         use_case_id: UseCaseID,

src/sentry/testutils/cases.py

@@ -43,6 +43,7 @@
 from rest_framework.response import Response
 from rest_framework.test import APITestCase as BaseAPITestCase
 from rest_framework.test import APITransactionTestCase as BaseAPITransactionTestCase
+from sentry_kafka_schemas.schema_types.snuba_spans_v1 import SpanEvent
 from sentry_kafka_schemas.schema_types.uptime_results_v1 import (
     CHECKSTATUS_FAILURE,
     CHECKSTATUSREASONTYPE_TIMEOUT,
@@ -279,6 +280,7 @@ def make_request(
         request.META["SERVER_NAME"] = "testserver"
         request.META["SERVER_PORT"] = 80
         if secure_scheme:
+            assert settings.SECURE_PROXY_SSL_HEADER is not None
             secure_header = settings.SECURE_PROXY_SSL_HEADER
             request.META[secure_header[0]] = secure_header[1]
 
@@ -1366,7 +1368,7 @@ def store_segment(
         transaction: str | None = None,
         duration: int = 10,
         exclusive_time: int = 5,
-        tags: Mapping[str, Any] | None = None,
+        tags: dict[str, str] | None = None,
         measurements: Mapping[str, int | float] | None = None,
         timestamp: datetime | None = None,
         sdk_name: str | None = None,
@@ -1380,7 +1382,7 @@ def store_segment(
         if timestamp is None:
             timestamp = timezone.now()
 
-        payload = {
+        payload: SpanEvent = {
             "project_id": project_id,
             "organization_id": organization_id,
             "span_id": span_id,
@@ -1389,7 +1391,7 @@ def store_segment(
             "start_timestamp_precise": timestamp.timestamp(),
             "end_timestamp_precise": timestamp.timestamp() + duration / 1000,
             "exclusive_time_ms": int(exclusive_time),
-            "description": transaction,
+            "description": transaction or "",
             "is_segment": True,
             "received": timezone.now().timestamp(),
             "start_timestamp_ms": int(timestamp.timestamp() * 1000),
@@ -1411,7 +1413,7 @@ def store_segment(
         if parent_span_id:
             payload["parent_span_id"] = parent_span_id
         if sdk_name is not None:
-            payload["sentry_tags"]["sdk.name"] = sdk_name
+            payload["sentry_tags"]["sdk.name"] = sdk_name  # type: ignore[typeddict-unknown-key]  # needs extra_items support
         if op is not None:
             payload["sentry_tags"]["op"] = op
         if status is not None:
@@ -1431,7 +1433,7 @@ def store_indexed_span(
         op: str | None = None,
         duration: int = 10,
         exclusive_time: int = 5,
-        tags: Mapping[str, Any] | None = None,
+        tags: dict[str, str] | None = None,
         measurements: Mapping[str, int | float] | None = None,
         timestamp: datetime | None = None,
         store_only_summary: bool = False,
@@ -1445,7 +1447,7 @@ def store_indexed_span(
         if timestamp is None:
             timestamp = timezone.now()
 
-        payload = {
+        payload: SpanEvent = {
             "project_id": project_id,
             "organization_id": organization_id,
             "span_id": span_id,
@@ -1479,7 +1481,7 @@ def store_indexed_span(
         if parent_span_id:
             payload["parent_span_id"] = parent_span_id
         if category is not None:
-            payload["sentry_tags"]["category"] = category
+            payload["sentry_tags"]["category"] = category  # type: ignore[typeddict-unknown-key]  # needs extra_items support
 
         # We want to give the caller the possibility to store only a summary since the database does not deduplicate
         # on the span_id which makes the assumptions of a unique span_id in the database invalid.