fix ruff pyupgrade rule (#341)

Author: gouline

dbtmetabase/__main__.py

@@ -1,7 +1,8 @@
 import functools
 import logging
+from collections.abc import Callable, Mapping, Sequence
 from pathlib import Path
-from typing import Any, Callable, List, Mapping, Optional, Sequence, Tuple, Union, cast
+from typing import Any, cast
 
 import click
 import yaml
@@ -22,8 +23,8 @@ def _click_list_option_kwargs() -> Mapping[str, Any]:
     def callback(
         ctx: click.Context,
         param: click.Option,
-        value: Union[str, List[str]],
-    ) -> Optional[List[str]]:
+        value: str | list[str],
+    ) -> list[str] | None:
         if value is None:
             return None
 
@@ -173,11 +174,11 @@ def wrapper(
         metabase_api_key: str,
         metabase_username: str,
         metabase_password: str,
-        metabase_session_id: Optional[str],
+        metabase_session_id: str | None,
         skip_verify: bool,
-        cert: Optional[str],
+        cert: str | None,
         http_timeout: int,
-        http_headers: Sequence[Tuple[str, str]],
+        http_headers: Sequence[tuple[str, str]],
         verbose: bool,
         **kwargs,
     ):
@@ -304,16 +305,16 @@ def wrapper(
 )
 def models(
     metabase_database: str,
-    include_databases: Optional[Sequence[str]],
-    exclude_databases: Optional[Sequence[str]],
-    include_schemas: Optional[Sequence[str]],
-    exclude_schemas: Optional[Sequence[str]],
-    include_models: Optional[Sequence[str]],
-    exclude_models: Optional[Sequence[str]],
+    include_databases: Sequence[str] | None,
+    exclude_databases: Sequence[str] | None,
+    include_schemas: Sequence[str] | None,
+    exclude_schemas: Sequence[str] | None,
+    include_models: Sequence[str] | None,
+    exclude_models: Sequence[str] | None,
     skip_sources: bool,
     sync_timeout: int,
     append_tags: bool,
-    docs_url: Optional[str],
+    docs_url: str | None,
     order_fields: bool,
     core: DbtMetabase,
 ):
@@ -387,9 +388,9 @@ def models(
 )
 def exposures(
     output_path: str,
-    output_grouping: Optional[str],
-    include_collections: Optional[Sequence[str]],
-    exclude_collections: Optional[Sequence[str]],
+    output_grouping: str | None,
+    include_collections: Sequence[str] | None,
+    exclude_collections: Sequence[str] | None,
     allow_personal_collections: bool,
     exclude_unverified: bool,
     tags: Sequence[str],

dbtmetabase/_exposures.py

@@ -4,19 +4,11 @@
 import logging
 import re
 from abc import ABCMeta, abstractmethod
+from collections.abc import Iterable, Mapping, MutableMapping, MutableSequence, Sequence
 from operator import itemgetter
 from pathlib import Path
 from typing import (
     Any,
-    Iterable,
-    Mapping,
-    MutableMapping,
-    MutableSequence,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    Union,
 )
 from urllib.parse import unquote
 
@@ -55,11 +47,11 @@ def metabase(self) -> Metabase:
     def extract_exposures(
         self,
         output_path: str = DEFAULT_EXPOSURES_OUTPUT_PATH,
-        output_grouping: Optional[str] = None,
-        collection_filter: Optional[Filter] = None,
+        output_grouping: str | None = None,
+        collection_filter: Filter | None = None,
         allow_personal_collections: bool = False,
         exclude_unverified: bool = False,
-        tags: Optional[Sequence[str]] = None,
+        tags: Sequence[str] | None = None,
     ) -> Iterable[Mapping]:
         """Extract dbt exposures from Metabase.
 
@@ -273,7 +265,7 @@ def __exposure_query(self, ctx: _Context, exposure: _Exposure, card: Mapping):
         dataset_query = card.get("dataset_query", {})
         query = dataset_query.get("query", {})
 
-        query_source: Union[str, int] = query.get("source-table", card.get("table_id"))
+        query_source: str | int = query.get("source-table", card.get("table_id"))
         if isinstance(query_source, str) and query_source.startswith("card__"):
             # Question based on another question
             source_card_uid = query_source.split("__")[-1]
@@ -288,7 +280,7 @@ def __exposure_query(self, ctx: _Context, exposure: _Exposure, card: Mapping):
 
         # Find models in joins
         for join in query.get("joins", []):
-            join_source: Union[str, int] = join.get("source-table")
+            join_source: str | int = join.get("source-table")
             if isinstance(join_source, str) and join_source.startswith("card__"):
                 # Question based on another question
                 source_card_uid = join_source.split("__")[-1]
@@ -338,8 +330,8 @@ def __exposure_mbql5_stage_mbql(
         """Extracts exposures from an MBQL 5 GUI stage."""
 
         # Extract source-table or source-card
-        source_table: Optional[int] = stage.get("source-table")
-        source_card: Optional[int] = stage.get("source-card")
+        source_table: int | None = stage.get("source-table")
+        source_card: int | None = stage.get("source-card")
 
         if source_card is not None:
             # Stage based on another card/question
@@ -437,11 +429,11 @@ def __format_exposure(
         created_at: str,
         creator_name: str,
         creator_email: str,
-        last_used_at: Optional[str],
-        average_query_time: Optional[str],
-        native_query: Optional[str],
+        last_used_at: str | None,
+        average_query_time: str | None,
+        native_query: str | None,
         depends_on: Iterable[str],
-        tags: Optional[Sequence[str]],
+        tags: Sequence[str] | None,
     ) -> Mapping:
         """Builds dbt exposure representation (see https://docs.getdbt.com/reference/exposure-properties)."""
 
@@ -510,13 +502,13 @@ def __write_exposures(
         self,
         exposures: Iterable[Mapping],
         output_path: str,
-        output_grouping: Optional[str],
+        output_grouping: str | None,
     ):
         """Write exposures to output files."""
 
-        grouped: MutableMapping[Tuple[str, ...], MutableSequence[Mapping]] = {}
+        grouped: MutableMapping[tuple[str, ...], MutableSequence[Mapping]] = {}
         for exposure in exposures:
-            group: Tuple[str, ...] = ("exposures",)
+            group: tuple[str, ...] = ("exposures",)
             if output_grouping == "collection":
                 group = (exposure["collection"],)
             elif output_grouping == "type":
@@ -563,7 +555,7 @@ class _Exposure:
     header: str = ""
     creator_name: str = ""
     creator_email: str = ""
-    average_query_time: Optional[str] = None
-    last_used_at: Optional[str] = None
-    native_query: Optional[str] = None
-    depends: Set[str] = dc.field(default_factory=set)
+    average_query_time: str | None = None
+    last_used_at: str | None = None
+    native_query: str | None = None
+    depends: set[str] = dc.field(default_factory=set)

dbtmetabase/_models.py

@@ -4,7 +4,8 @@
 import logging
 import time
 from abc import ABCMeta, abstractmethod
-from typing import Any, Iterable, Mapping, MutableMapping, Optional
+from collections.abc import Iterable, Mapping, MutableMapping
+from typing import Any
 
 from .errors import MetabaseStateError
 from .format import Filter, NullValue, safe_name
@@ -34,13 +35,13 @@ def metabase(self) -> Metabase:
     def export_models(
         self,
         metabase_database: str,
-        database_filter: Optional[Filter] = None,
-        schema_filter: Optional[Filter] = None,
-        model_filter: Optional[Filter] = None,
+        database_filter: Filter | None = None,
+        schema_filter: Filter | None = None,
+        model_filter: Filter | None = None,
         skip_sources: bool = False,
         sync_timeout: int = DEFAULT_MODELS_SYNC_TIMEOUT,
         append_tags: bool = False,
-        docs_url: Optional[str] = None,
+        docs_url: str | None = None,
         order_fields: bool = False,
     ):
         """Exports dbt models to Metabase database schema.
@@ -171,7 +172,7 @@ def _export_model(
         ctx: _Context,
         model: Model,
         append_tags: bool,
-        docs_url: Optional[str],
+        docs_url: str | None,
         order_fields: bool,
     ) -> bool:
         """Exports one dbt model to Metabase database schema."""
@@ -422,7 +423,7 @@ def __export_column(
         if api_field["fk_target_field_id"] and not fk_target_field_id:
             fk_target_field_id = api_field["fk_target_field_id"]
 
-        body_field: MutableMapping[str, Optional[Any]] = {}
+        body_field: MutableMapping[str, Any | None] = {}
 
         # Update if specified, otherwise reset one that had been set
         api_display_name = api_field.get("display_name")
@@ -529,9 +530,9 @@ def _get_metabase_tables(self, database_id: str) -> Mapping[str, MutableMapping]
     def __filtered_models(
         self,
         models: Iterable[Model],
-        database_filter: Optional[Filter],
-        schema_filter: Optional[Filter],
-        model_filter: Optional[Filter],
+        database_filter: Filter | None,
+        schema_filter: Filter | None,
+        model_filter: Filter | None,
         skip_sources: bool,
     ) -> Iterable[Model]:
         def selected(m: Model) -> bool:

dbtmetabase/core.py

@@ -2,7 +2,6 @@
 
 import logging
 from pathlib import Path
-from typing import Optional, Tuple, Union
 
 from requests.adapters import HTTPAdapter
 
@@ -21,17 +20,17 @@ class DbtMetabase(ModelsMixin, ExposuresMixin):
 
     def __init__(
         self,
-        manifest_path: Union[str, Path],
+        manifest_path: str | Path,
         metabase_url: str,
-        metabase_api_key: Optional[str] = None,
-        metabase_username: Optional[str] = None,
-        metabase_password: Optional[str] = None,
-        metabase_session_id: Optional[str] = None,
+        metabase_api_key: str | None = None,
+        metabase_username: str | None = None,
+        metabase_password: str | None = None,
+        metabase_session_id: str | None = None,
         skip_verify: bool = False,
-        cert: Optional[Union[str, Tuple[str, str]]] = None,
+        cert: str | tuple[str, str] | None = None,
         http_timeout: int = DEFAULT_HTTP_TIMEOUT,
-        http_headers: Optional[dict] = None,
-        http_adapter: Optional[HTTPAdapter] = None,
+        http_headers: dict | None = None,
+        http_adapter: HTTPAdapter | None = None,
     ):
         """dbt + Metabase integration.
 

dbtmetabase/format.py

@@ -3,9 +3,10 @@
 import fnmatch
 import logging
 import re
+from collections.abc import MutableSequence, Sequence
 from logging.handlers import RotatingFileHandler
 from pathlib import Path
-from typing import Any, MutableSequence, Optional, Sequence, TextIO
+from typing import Any, TextIO
 
 import yaml
 from rich.logging import RichHandler
@@ -16,8 +17,8 @@ class Filter:
 
     def __init__(
         self,
-        include: Optional[Sequence[str]] = None,
-        exclude: Optional[Sequence[str]] = None,
+        include: Sequence[str] | None = None,
+        exclude: Sequence[str] | None = None,
     ):
         """Inclusion/exclusion filtering.
 
@@ -28,7 +29,7 @@ def __init__(
         self.include = self._norm_arg(include)
         self.exclude = self._norm_arg(exclude)
 
-    def match(self, item: Optional[str]) -> bool:
+    def match(self, item: str | None) -> bool:
         item = self._norm_item(item) if item else ""
 
         for exclude in self.exclude:
@@ -44,7 +45,7 @@ def match(self, item: Optional[str]) -> bool:
         return True
 
     @staticmethod
-    def _norm_arg(arg: Optional[Sequence[str]]) -> Sequence[str]:
+    def _norm_arg(arg: Sequence[str] | None) -> Sequence[str]:
         if isinstance(arg, str):
             arg = [arg]
         return [Filter._norm_item(x) for x in arg or []]
@@ -88,7 +89,7 @@ def dump_yaml(data: Any, stream: TextIO):
     )
 
 
-def setup_logging(level: int, path: Optional[Path] = None):
+def setup_logging(level: int, path: Path | None = None):
     """Basic logger configuration for the CLI.
 
     Args:
@@ -129,7 +130,7 @@ def setup_logging(level: int, path: Optional[Path] = None):
     )
 
 
-def safe_name(text: Optional[str]) -> str:
+def safe_name(text: str | None) -> str:
     """Sanitizes a human-readable "friendly" name to a safe string.
 
     For example, "Joe's Collection" becomes "joe_s_collection".
@@ -143,7 +144,7 @@ def safe_name(text: Optional[str]) -> str:
     return re.sub(r"[^\w]", "_", text or "").lower()
 
 
-def safe_description(text: Optional[str]) -> str:
+def safe_description(text: str | None) -> str:
     """Sanitizes a human-readable long text, such as description.
 
     Args: