Lint: Add upgrade rules

And stabilise on up-to-date typing APIs

Author: Epse

pyproject.toml

@@ -59,6 +59,6 @@ strict = true
 include = ["src/obelisk/**/*.py"]
 
 [tool.ruff.lint]
-select = ["E4", "E7", "E9", "F", "ASYNC", "S", "B", "FIX", "SIM", "C90", "N", "PERF"]
+select = ["E4", "E7", "E9", "F", "ASYNC", "S", "B", "FIX", "SIM", "C90", "N", "PERF", "UP"]
 # Ignore N815, camelcase field names are usually for serialisation reasons
 ignore = ["N815"]

src/obelisk/asynchronous/base.py

@@ -1,7 +1,7 @@
 from datetime import datetime, timedelta
 import logging
 import base64
-from typing import Any, Optional
+from typing import Any
 
 import httpx
 
@@ -19,9 +19,9 @@ class BaseClient:
     _client: str = ""
     _secret: str = ""
 
-    _token: Optional[str] = None
+    _token: str | None = None
     """Current authentication token"""
-    _token_expires: Optional[datetime] = None
+    _token_expires: datetime | None = None
     """Deadline after which token is no longer useable"""
 
     grace_period: timedelta = timedelta(seconds=10)
@@ -47,7 +47,7 @@ def __init__(
 
     async def _get_token(self) -> None:
         auth_string = str(
-            base64.b64encode(f"{self._client}:{self._secret}".encode("utf-8")), "utf-8"
+            base64.b64encode(f"{self._client}:{self._secret}".encode()), "utf-8"
         )
         headers = {
             "Authorization": f"Basic {auth_string}",
@@ -113,7 +113,7 @@ async def _verify_token(self) -> None:
                     continue
 
     async def http_post(
-        self, url: str, data: Any = None, params: Optional[dict[str, str]] = None
+        self, url: str, data: Any = None, params: dict[str, str] | None = None
     ) -> httpx.Response:
         """
         Send an HTTP POST request to Obelisk,
@@ -162,7 +162,7 @@ async def http_post(
             return response
 
     async def http_get(
-        self, url: str, params: Optional[dict[str, str]] = None
+        self, url: str, params: dict[str, str] | None = None
     ) -> httpx.Response:
         """
         Send an HTTP GET request to Obelisk,

src/obelisk/asynchronous/client.py

@@ -1,7 +1,8 @@
 import json
 from datetime import datetime, timedelta
 from math import floor
-from typing import Any, AsyncGenerator, List, Literal, Optional
+from typing import Any, Literal
+from collections.abc import AsyncGenerator
 
 import httpx
 from pydantic import ValidationError
@@ -23,16 +24,16 @@ class Obelisk(BaseClient):
 
     async def fetch_single_chunk(
         self,
-        datasets: List[str],
-        metrics: Optional[List[str]] = None,
-        fields: Optional[List[str]] = None,
-        from_timestamp: Optional[int] = None,
-        to_timestamp: Optional[int] = None,
-        order_by: Optional[dict[str, Any]] = None,
-        filter_: Optional[dict[str, Any]] = None,
-        limit: Optional[int] = None,
-        limit_by: Optional[dict[str, Any]] = None,
-        cursor: Optional[str] = None,
+        datasets: list[str],
+        metrics: list[str] | None = None,
+        fields: list[str] | None = None,
+        from_timestamp: int | None = None,
+        to_timestamp: int | None = None,
+        order_by: dict[str, Any] | None = None,
+        filter_: dict[str, Any] | None = None,
+        limit: int | None = None,
+        limit_by: dict[str, Any] | None = None,
+        cursor: str | None = None,
     ) -> QueryResult:
         """
         Queries one chunk of events from Obelisk for given parameters,
@@ -111,16 +112,16 @@ async def fetch_single_chunk(
 
     async def query(
         self,
-        datasets: List[str],
-        metrics: Optional[List[str]] = None,
-        fields: Optional[List[str]] = None,
-        from_timestamp: Optional[int] = None,
-        to_timestamp: Optional[int] = None,
-        order_by: Optional[dict[str, Any]] = None,
-        filter_: Optional[dict[str, Any]] = None,
-        limit: Optional[int] = None,
-        limit_by: Optional[dict[str, Any]] = None,
-    ) -> List[Datapoint]:
+        datasets: list[str],
+        metrics: list[str] | None = None,
+        fields: list[str] | None = None,
+        from_timestamp: int | None = None,
+        to_timestamp: int | None = None,
+        order_by: dict[str, Any] | None = None,
+        filter_: dict[str, Any] | None = None,
+        limit: int | None = None,
+        limit_by: dict[str, Any] | None = None,
+    ) -> list[Datapoint]:
         """
         Queries data from obelisk,
         automatically iterating when a cursor is returned.
@@ -157,8 +158,8 @@ async def query(
             to a specified maximum number.
         """
 
-        cursor: Optional[str] | Literal[True] = True
-        result_set: List[Datapoint] = []
+        cursor: str | None | Literal[True] = True
+        result_set: list[Datapoint] = []
 
         while cursor:
             actual_cursor = cursor if cursor is not True else None
@@ -191,14 +192,14 @@ async def query(
 
     async def query_time_chunked(
         self,
-        datasets: List[str],
-        metrics: List[str],
+        datasets: list[str],
+        metrics: list[str],
         from_time: datetime,
         to_time: datetime,
         jump: timedelta,
-        filter_: Optional[dict[str, Any]] = None,
+        filter_: dict[str, Any] | None = None,
         direction: Literal["asc", "desc"] = "asc",
-    ) -> AsyncGenerator[List[Datapoint], None]:
+    ) -> AsyncGenerator[list[Datapoint], None]:
         """
         Fetches all data matching the provided filters,
         yielding one chunk at a time.
@@ -239,7 +240,7 @@ async def query_time_chunked(
     async def send(
         self,
         dataset: str,
-        data: List[dict[str, Any]],
+        data: list[dict[str, Any]],
         precision: TimestampPrecision = TimestampPrecision.MILLISECONDS,
         mode: IngestMode = IngestMode.DEFAULT,
     ) -> httpx.Response:

src/obelisk/asynchronous/core.py

@@ -25,16 +25,12 @@
 )
 from typing import (
     Annotated,
-    AsyncIterator,
-    Dict,
-    Iterator,
-    List,
     Literal,
-    Optional,
     Any,
     cast,
     get_args,
 )
+from collections.abc import AsyncIterator, Iterator
 from typing_extensions import Self
 from numbers import Number
 
@@ -71,7 +67,7 @@ def type_suffix(metric: str) -> DataType:
 """Type of aggregation Obelisk can process"""
 
 
-Datapoint = Dict[str, Any]
+Datapoint = dict[str, Any]
 """Datapoints resulting from queries are modeled as simple dicts, as fields can come and go depending on query."""
 
 
@@ -92,11 +88,11 @@ class IncomingDatapoint(BaseModel):
     .. automethod:: check_metric_type(self)
     """
 
-    timestamp: Optional[AwareDatetime] = None
+    timestamp: AwareDatetime | None = None
     metric: str
     value: Any
-    labels: Optional[Dict[str, str]] = None
-    location: Optional[ObeliskPosition] = None
+    labels: dict[str, str] | None = None
+    location: ObeliskPosition | None = None
 
     @model_validator(mode="after")
     def check_metric_type(self) -> Self:
@@ -130,23 +126,21 @@ def check_metric_type(self) -> Self:
 
 class QueryParams(BaseModel):
     dataset: str
-    groupBy: Optional[List[FieldName]] = None
-    aggregator: Optional[Aggregator] = None
-    fields: Optional[List[FieldName]] = None
-    orderBy: Optional[List[str]] = (
+    groupBy: list[FieldName] | None = None
+    aggregator: Aggregator | None = None
+    fields: list[FieldName] | None = None
+    orderBy: list[str] | None = (
         None  # More complex than just FieldName, can be prefixed with - to invert sort
     )
-    dataType: Optional[DataType] = None
-    filter_: Annotated[Optional[str | Filter], Field(serialization_alias="filter")] = (
-        None
-    )
+    dataType: DataType | None = None
+    filter_: Annotated[str | Filter | None, Field(serialization_alias="filter")] = None
     """
     Obelisk CORE handles filtering in `RSQL format <https://obelisk.pages.ilabt.imec.be/obelisk-core/query.html#rsql-format>`__ ,
     to make it easier to also programatically write these filters, we provide the :class:`Filter` option as well.
 
     Suffix to avoid collisions.
     """
-    cursor: Optional[str] = None
+    cursor: str | None = None
     limit: int = 1000
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
@@ -164,14 +158,14 @@ def to_dict(self) -> dict[str, Any]:
 
 class ChunkedParams(BaseModel):
     dataset: str
-    groupBy: Optional[List[FieldName]] = None
-    aggregator: Optional[Aggregator] = None
-    fields: Optional[List[FieldName]] = None
-    orderBy: Optional[List[str]] = (
+    groupBy: list[FieldName] | None = None
+    aggregator: Aggregator | None = None
+    fields: list[FieldName] | None = None
+    orderBy: list[str] | None = (
         None  # More complex than just FieldName, can be prefixed with - to invert sort
     )
-    dataType: Optional[DataType] = None
-    filter_: Optional[str | Filter] = None
+    dataType: DataType | None = None
+    filter_: str | Filter | None = None
     """Underscore suffix to avoid name collisions"""
     start: datetime
     end: datetime
@@ -208,8 +202,8 @@ def chunks(self) -> Iterator[QueryParams]:
 
 
 class QueryResult(BaseModel):
-    cursor: Optional[str] = None
-    items: List[Datapoint]
+    cursor: str | None = None
+    items: list[Datapoint]
 
 
 class Client(BaseClient):
@@ -233,7 +227,7 @@ def __init__(
     async def send(
         self,
         dataset: str,
-        data: List[IncomingDatapoint],
+        data: list[IncomingDatapoint],
     ) -> httpx.Response:
         """
         Publishes data to Obelisk
@@ -285,9 +279,9 @@ async def fetch_single_chunk(self, params: QueryParams) -> QueryResult:
             self.log.warning(msg)
             raise ObeliskError(msg) from e
 
-    async def query(self, params: QueryParams) -> List[Datapoint]:
+    async def query(self, params: QueryParams) -> list[Datapoint]:
         params.cursor = None
-        result_set: List[Datapoint] = []
+        result_set: list[Datapoint] = []
         result_limit = params.limit
 
         # Obelisk CORE does not actually stop emitting a cursor when done, limit serves as page limit
@@ -305,6 +299,6 @@ async def query(self, params: QueryParams) -> List[Datapoint]:
 
     async def query_time_chunked(
         self, params: ChunkedParams
-    ) -> AsyncIterator[List[Datapoint]]:
+    ) -> AsyncIterator[list[Datapoint]]:
         for chunk in params.chunks():
             yield await self.query(chunk)

src/obelisk/sync/client.py

@@ -1,7 +1,8 @@
 import asyncio
 from datetime import datetime, timedelta
 from math import floor
-from typing import Any, Generator, List, Literal, Optional
+from typing import Any, Literal
+from collections.abc import Generator
 
 import httpx
 
@@ -44,16 +45,16 @@ def __init__(
 
     def fetch_single_chunk(
         self,
-        datasets: List[str],
-        metrics: Optional[List[str]] = None,
-        fields: Optional[List[str]] = None,
-        from_timestamp: Optional[int] = None,
-        to_timestamp: Optional[int] = None,
-        order_by: Optional[dict[str, Any]] = None,
-        filter_: Optional[dict[str, Any]] = None,
-        limit: Optional[int] = None,
-        limit_by: Optional[dict[str, Any]] = None,
-        cursor: Optional[str] = None,
+        datasets: list[str],
+        metrics: list[str] | None = None,
+        fields: list[str] | None = None,
+        from_timestamp: int | None = None,
+        to_timestamp: int | None = None,
+        order_by: dict[str, Any] | None = None,
+        filter_: dict[str, Any] | None = None,
+        limit: int | None = None,
+        limit_by: dict[str, Any] | None = None,
+        cursor: str | None = None,
     ) -> QueryResult:
         """
         Queries one chunk of events from Obelisk for given parameters,
@@ -114,16 +115,16 @@ def fetch_single_chunk(
 
     def query(
         self,
-        datasets: List[str],
-        metrics: Optional[List[str]] = None,
-        fields: Optional[List[str]] = None,
-        from_timestamp: Optional[int] = None,
-        to_timestamp: Optional[int] = None,
-        order_by: Optional[dict[str, Any]] = None,
-        filter_: Optional[dict[str, Any]] = None,
-        limit: Optional[int] = None,
-        limit_by: Optional[dict[str, Any]] = None,
-    ) -> List[Datapoint]:
+        datasets: list[str],
+        metrics: list[str] | None = None,
+        fields: list[str] | None = None,
+        from_timestamp: int | None = None,
+        to_timestamp: int | None = None,
+        order_by: dict[str, Any] | None = None,
+        filter_: dict[str, Any] | None = None,
+        limit: int | None = None,
+        limit_by: dict[str, Any] | None = None,
+    ) -> list[Datapoint]:
         """
         Queries data from obelisk,
         automatically iterating when a cursor is returned.
@@ -177,14 +178,14 @@ def query(
 
     def query_time_chunked(
         self,
-        datasets: List[str],
-        metrics: List[str],
+        datasets: list[str],
+        metrics: list[str],
         from_time: datetime,
         to_time: datetime,
         jump: timedelta,
-        filter_: Optional[dict[str, Any]] = None,
+        filter_: dict[str, Any] | None = None,
         direction: Literal["asc", "desc"] = "asc",
-    ) -> Generator[List[Datapoint], None, None]:
+    ) -> Generator[list[Datapoint], None, None]:
         """
         Fetches all data matching the provided filters,
         yielding one chunk at a time.
@@ -225,7 +226,7 @@ def query_time_chunked(
     def send(
         self,
         dataset: str,
-        data: List[dict[str, Any]],
+        data: list[dict[str, Any]],
         precision: TimestampPrecision = TimestampPrecision.MILLISECONDS,
         mode: IngestMode = IngestMode.DEFAULT,
     ) -> httpx.Response: