chore(pre-commit): Add pyupgrade and pycln hooks (#24197)

superset/common/query_object.py

@@ -21,7 +21,7 @@ import json
 import logging
 from datetime import datetime
 from pprint import pformat
-from typing import Any, Dict, List, NamedTuple, Optional, TYPE_CHECKING
+from typing import Any, NamedTuple, TYPE_CHECKING
 
 from flask import g
 from flask_babel import gettext as _
@@ -81,58 +81,58 @@ class QueryObject:  # pylint: disable=too-many-instance-attributes
     and druid. The query objects are constructed on the client.
     """
 
-    annotation_layers: List[Dict[str, Any]]
-    applied_time_extras: Dict[str, str]
+    annotation_layers: list[dict[str, Any]]
+    applied_time_extras: dict[str, str]
     apply_fetch_values_predicate: bool
-    columns: List[Column]
-    datasource: Optional[BaseDatasource]
-    extras: Dict[str, Any]
-    filter: List[QueryObjectFilterClause]
-    from_dttm: Optional[datetime]
-    granularity: Optional[str]
-    inner_from_dttm: Optional[datetime]
-    inner_to_dttm: Optional[datetime]
+    columns: list[Column]
+    datasource: BaseDatasource | None
+    extras: dict[str, Any]
+    filter: list[QueryObjectFilterClause]
+    from_dttm: datetime | None
+    granularity: str | None
+    inner_from_dttm: datetime | None
+    inner_to_dttm: datetime | None
     is_rowcount: bool
     is_timeseries: bool
-    metrics: Optional[List[Metric]]
+    metrics: list[Metric] | None
     order_desc: bool
-    orderby: List[OrderBy]
-    post_processing: List[Dict[str, Any]]
-    result_type: Optional[ChartDataResultType]
-    row_limit: Optional[int]
+    orderby: list[OrderBy]
+    post_processing: list[dict[str, Any]]
+    result_type: ChartDataResultType | None
+    row_limit: int | None
     row_offset: int
-    series_columns: List[Column]
+    series_columns: list[Column]
     series_limit: int
-    series_limit_metric: Optional[Metric]
-    time_offsets: List[str]
-    time_shift: Optional[str]
-    time_range: Optional[str]
-    to_dttm: Optional[datetime]
+    series_limit_metric: Metric | None
+    time_offsets: list[str]
+    time_shift: str | None
+    time_range: str | None
+    to_dttm: datetime | None
 
     def __init__(  # pylint: disable=too-many-locals
         self,
         *,
-        annotation_layers: Optional[List[Dict[str, Any]]] = None,
-        applied_time_extras: Optional[Dict[str, str]] = None,
+        annotation_layers: list[dict[str, Any]] | None = None,
+        applied_time_extras: dict[str, str] | None = None,
         apply_fetch_values_predicate: bool = False,
-        columns: Optional[List[Column]] = None,
-        datasource: Optional[BaseDatasource] = None,
-        extras: Optional[Dict[str, Any]] = None,
-        filters: Optional[List[QueryObjectFilterClause]] = None,
-        granularity: Optional[str] = None,
+        columns: list[Column] | None = None,
+        datasource: BaseDatasource | None = None,
+        extras: dict[str, Any] | None = None,
+        filters: list[QueryObjectFilterClause] | None = None,
+        granularity: str | None = None,
         is_rowcount: bool = False,
-        is_timeseries: Optional[bool] = None,
-        metrics: Optional[List[Metric]] = None,
+        is_timeseries: bool | None = None,
+        metrics: list[Metric] | None = None,
         order_desc: bool = True,
-        orderby: Optional[List[OrderBy]] = None,
-        post_processing: Optional[List[Optional[Dict[str, Any]]]] = None,
-        row_limit: Optional[int],
-        row_offset: Optional[int] = None,
-        series_columns: Optional[List[Column]] = None,
+        orderby: list[OrderBy] | None = None,
+        post_processing: list[dict[str, Any] | None] | None = None,
+        row_limit: int | None,
+        row_offset: int | None = None,
+        series_columns: list[Column] | None = None,
         series_limit: int = 0,
-        series_limit_metric: Optional[Metric] = None,
-        time_range: Optional[str] = None,
-        time_shift: Optional[str] = None,
+        series_limit_metric: Metric | None = None,
+        time_range: str | None = None,
+        time_shift: str | None = None,
         **kwargs: Any,
     ):
         self._set_annotation_layers(annotation_layers)
@@ -166,7 +166,7 @@ class QueryObject:  # pylint: disable=too-many-instance-attributes
         self._move_deprecated_extra_fields(kwargs)
 
     def _set_annotation_layers(
-        self, annotation_layers: Optional[List[Dict[str, Any]]]
+        self, annotation_layers: list[dict[str, Any]] | None
     ) -> None:
         self.annotation_layers = [
             layer
@@ -175,14 +175,14 @@ class QueryObject:  # pylint: disable=too-many-instance-attributes
             if layer["annotationType"] != "FORMULA"
         ]
 
-    def _set_is_timeseries(self, is_timeseries: Optional[bool]) -> None:
+    def _set_is_timeseries(self, is_timeseries: bool | None) -> None:
         # is_timeseries is True if time column is in either columns or groupby
         # (both are dimensions)
         self.is_timeseries = (
             is_timeseries if is_timeseries is not None else DTTM_ALIAS in self.columns
         )
 
-    def _set_metrics(self, metrics: Optional[List[Metric]] = None) -> None:
+    def _set_metrics(self, metrics: list[Metric] | None = None) -> None:
         # Support metric reference/definition in the format of
         #   1. 'metric_name'   - name of predefined metric
         #   2. { label: 'label_name' }  - legacy format for a predefined metric
@@ -195,16 +195,16 @@ class QueryObject:  # pylint: disable=too-many-instance-attributes
         ]
 
     def _set_post_processing(
-        self, post_processing: Optional[List[Optional[Dict[str, Any]]]]
+        self, post_processing: list[dict[str, Any] | None] | None
     ) -> None:
         post_processing = post_processing or []
         self.post_processing = [post_proc for post_proc in post_processing if post_proc]
 
     def _init_series_columns(
         self,
-        series_columns: Optional[List[Column]],
-        metrics: Optional[List[Metric]],
-        is_timeseries: Optional[bool],
+        series_columns: list[Column] | None,
+        metrics: list[Metric] | None,
+        is_timeseries: bool | None,
     ) -> None:
         if series_columns:
             self.series_columns = series_columns
@@ -213,7 +213,7 @@ class QueryObject:  # pylint: disable=too-many-instance-attributes
         else:
             self.series_columns = []
 
-    def _rename_deprecated_fields(self, kwargs: Dict[str, Any]) -> None:
+    def _rename_deprecated_fields(self, kwargs: dict[str, Any]) -> None:
         # rename deprecated fields
         for field in DEPRECATED_FIELDS:
             if field.old_name in kwargs:
@@ -233,7 +233,7 @@ class QueryObject:  # pylint: disable=too-many-instance-attributes
                         )
                     setattr(self, field.new_name, value)
 
-    def _move_deprecated_extra_fields(self, kwargs: Dict[str, Any]) -> None:
+    def _move_deprecated_extra_fields(self, kwargs: dict[str, Any]) -> None:
         # move deprecated extras fields to extras
         for field in DEPRECATED_EXTRAS_FIELDS:
             if field.old_name in kwargs:
@@ -256,19 +256,19 @@ class QueryObject:  # pylint: disable=too-many-instance-attributes
                     self.extras[field.new_name] = value
 
     @property
-    def metric_names(self) -> List[str]:
+    def metric_names(self) -> list[str]:
         """Return metrics names (labels), coerce adhoc metrics to strings."""
         return get_metric_names(self.metrics or [])
 
     @property
-    def column_names(self) -> List[str]:
+    def column_names(self) -> list[str]:
         """Return column names (labels). Gives priority to groupbys if both groupbys
         and metrics are non-empty, otherwise returns column labels."""
         return get_column_names(self.columns)
 
     def validate(
-        self, raise_exceptions: Optional[bool] = True
-    ) -> Optional[QueryObjectValidationError]:
+        self, raise_exceptions: bool | None = True
+    ) -> QueryObjectValidationError | None:
         """Validate query object"""
         try:
             self._validate_there_are_no_missing_series()
@@ -314,7 +314,7 @@ class QueryObject:  # pylint: disable=too-many-instance-attributes
                 )
             )
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         query_object_dict = {
             "apply_fetch_values_predicate": self.apply_fetch_values_predicate,
             "columns": self.columns,