mapillary-tools 0.14.0a1__py3-none-any.whl → 0.14.0a2__py3-none-any.whl

mapillary_tools/__init__.py

@@ -1 +1 @@
-VERSION = "0.14.0a1"
+VERSION = "0.14.0a2"

mapillary_tools/api_v4.py

@@ -135,7 +135,7 @@ def _log_debug_response(resp: requests.Response):
     if logging.getLogger().getEffectiveLevel() <= logging.DEBUG:
         return
 
-    data: T.Union[str, bytes]
+    data: str | bytes
     try:
         data = _truncate(dumps(_sanitize(resp.json())))
     except Exception:
@@ -148,7 +148,7 @@ def readable_http_error(ex: requests.HTTPError) -> str:
     req = ex.request
     resp = ex.response
 
-    data: T.Union[str, bytes]
+    data: str | bytes
     try:
         data = _truncate(dumps(_sanitize(resp.json())))
     except Exception:
@@ -284,7 +284,7 @@ def get_upload_token(email: str, password: str) -> requests.Response:
 
 
 def fetch_organization(
-    user_access_token: str, organization_id: T.Union[int, str]
+    user_access_token: str, organization_id: int | str
 ) -> requests.Response:
     resp = request_get(
         f"{MAPILLARY_GRAPH_API_ENDPOINT}/{organization_id}",
@@ -329,7 +329,7 @@ ActionType = T.Literal[
 ]
 
 
-def log_event(action_type: ActionType, properties: T.Dict) -> requests.Response:
+def log_event(action_type: ActionType, properties: dict) -> requests.Response:
     resp = request_post(
         f"{MAPILLARY_GRAPH_API_ENDPOINT}/logging",
         json={

mapillary_tools/camm/camm_parser.py

@@ -373,7 +373,7 @@ SAMPLE_ENTRY_CLS_BY_CAMM_TYPE = {
 assert len(SAMPLE_ENTRY_CLS_BY_CAMM_TYPE) == 5, SAMPLE_ENTRY_CLS_BY_CAMM_TYPE.keys()
 
 
-_SWITCH: T.Dict[int, C.Struct] = {
+_SWITCH: dict[int, C.Struct] = {
     # Angle_axis
     CAMMType.ANGLE_AXIS.value: _Float[3],  # type: ignore
     # Exposure time
@@ -436,7 +436,7 @@ def _parse_telemetry_from_sample(
 
 def _filter_telemetry_by_elst_segments(
     measurements: T.Iterable[TelemetryMeasurement],
-    elst: T.Sequence[T.Tuple[float, float]],
+    elst: T.Sequence[tuple[float, float]],
 ) -> T.Generator[TelemetryMeasurement, None, None]:
     empty_elst = [entry for entry in elst if entry[0] == -1]
     if empty_elst:
@@ -466,8 +466,8 @@ def _filter_telemetry_by_elst_segments(
 
 
 def elst_entry_to_seconds(
-    entry: T.Dict, movie_timescale: int, media_timescale: int
-) -> T.Tuple[float, float]:
+    entry: dict, movie_timescale: int, media_timescale: int
+) -> tuple[float, float]:
     assert movie_timescale > 0, "expected positive movie_timescale"
     assert media_timescale > 0, "expected positive media_timescale"
     media_time, duration = entry["media_time"], entry["segment_duration"]
@@ -477,7 +477,7 @@ def elst_entry_to_seconds(
     return (media_time, duration)
 
 
-def _is_camm_description(description: T.Dict) -> bool:
+def _is_camm_description(description: dict) -> bool:
     return description["format"] == b"camm"
 
 

mapillary_tools/commands/__main__.py

@@ -2,7 +2,6 @@ import argparse
 import enum
 import logging
 import sys
-import typing as T
 from pathlib import Path
 
 import requests
@@ -86,7 +85,7 @@ def configure_logger(logger: logging.Logger, stream=None) -> None:
     logger.addHandler(handler)
 
 
-def _log_params(argvars: T.Dict) -> None:
+def _log_params(argvars: dict) -> None:
     MAX_ENTRIES = 5
 
     def _stringify(x) -> str:

mapillary_tools/config.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import configparser
 import os
 import typing as T
@@ -35,8 +37,8 @@ def _load_config(config_path: str) -> configparser.ConfigParser:
 
 
 def load_user(
-    profile_name: str, config_path: T.Optional[str] = None
-) -> T.Optional[types.UserItem]:
+    profile_name: str, config_path: str | None = None
+) -> types.UserItem | None:
     if config_path is None:
         config_path = MAPILLARY_CONFIG_PATH
     config = _load_config(config_path)
@@ -46,7 +48,7 @@ def load_user(
     return T.cast(types.UserItem, user_items)
 
 
-def list_all_users(config_path: T.Optional[str] = None) -> T.Dict[str, types.UserItem]:
+def list_all_users(config_path: str | None = None) -> dict[str, types.UserItem]:
     if config_path is None:
         config_path = MAPILLARY_CONFIG_PATH
     cp = _load_config(config_path)
@@ -58,7 +60,7 @@ def list_all_users(config_path: T.Optional[str] = None) -> T.Dict[str, types.Use
 
 
 def update_config(
-    profile_name: str, user_items: types.UserItem, config_path: T.Optional[str] = None
+    profile_name: str, user_items: types.UserItem, config_path: str | None = None
 ) -> None:
     if config_path is None:
         config_path = MAPILLARY_CONFIG_PATH
@@ -72,7 +74,7 @@ def update_config(
         config.write(fp)
 
 
-def remove_config(profile_name: str, config_path: T.Optional[str] = None) -> None:
+def remove_config(profile_name: str, config_path: str | None = None) -> None:
     if config_path is None:
         config_path = MAPILLARY_CONFIG_PATH
 

mapillary_tools/constants.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import os
-import typing as T
 
 import appdirs
 
@@ -52,7 +51,7 @@ UPLOAD_CHUNK_SIZE_MB = float(os.getenv(_ENV_PREFIX + "UPLOAD_CHUNK_SIZE_MB", 1))
 # It is used to filter out noisy points
 GOPRO_MAX_DOP100 = int(os.getenv(_ENV_PREFIX + "GOPRO_MAX_DOP100", 1000))
 # Within the GPS stream: 0 - no lock, 2 or 3 - 2D or 3D Lock
-GOPRO_GPS_FIXES: T.Set[int] = set(
+GOPRO_GPS_FIXES: set[int] = set(
     int(fix) for fix in os.getenv(_ENV_PREFIX + "GOPRO_GPS_FIXES", "2,3").split(",")
 )
 MAX_UPLOAD_RETRIES: int = int(os.getenv(_ENV_PREFIX + "MAX_UPLOAD_RETRIES", 200))

mapillary_tools/exceptions.py

@@ -87,7 +87,7 @@ class MapillaryDuplicationError(MapillaryDescriptionError):
         self.angle_diff = angle_diff
 
 
-class MapillaryEXIFNotFoundError(MapillaryDescriptionError):
+class MapillaryExifToolXMLNotFoundError(MapillaryDescriptionError):
     pass
 
 

mapillary_tools/exif_read.py

@@ -36,7 +36,7 @@ def eval_frac(value: Ratio) -> float:
     return float(value.num) / float(value.den)
 
 
-def gps_to_decimal(values: T.Tuple[Ratio, Ratio, Ratio]) -> T.Optional[float]:
+def gps_to_decimal(values: tuple[Ratio, Ratio, Ratio]) -> float | None:
     try:
         deg, min, sec, *_ = values
     except (TypeError, ValueError):
@@ -56,14 +56,14 @@ def gps_to_decimal(values: T.Tuple[Ratio, Ratio, Ratio]) -> T.Optional[float]:
     return degrees + minutes / 60 + seconds / 3600
 
 
-def _parse_coord_numeric(coord: str, ref: T.Optional[str]) -> T.Optional[float]:
+def _parse_coord_numeric(coord: str, ref: str | None) -> float | None:
     try:
         return float(coord) * SIGN_BY_DIRECTION[ref]
     except (ValueError, KeyError):
         return None
 
 
-def _parse_coord_adobe(coord: str) -> T.Optional[float]:
+def _parse_coord_adobe(coord: str) -> float | None:
     """
     Parse Adobe coordinate format: <degrees,fractionalminutes[NSEW]>
     """
@@ -79,7 +79,7 @@ def _parse_coord_adobe(coord: str) -> T.Optional[float]:
     return None
 
 
-def _parse_coord(coord: T.Optional[str], ref: T.Optional[str]) -> T.Optional[float]:
+def _parse_coord(coord: str | None, ref: str | None) -> float | None:
     if coord is None:
         return None
     parsed = _parse_coord_numeric(coord, ref)
@@ -88,7 +88,7 @@ def _parse_coord(coord: T.Optional[str], ref: T.Optional[str]) -> T.Optional[flo
     return parsed
 
 
-def _parse_iso(dtstr: str) -> T.Optional[datetime.datetime]:
+def _parse_iso(dtstr: str) -> datetime.datetime | None:
     try:
         return datetime.datetime.fromisoformat(dtstr)
     except ValueError:
@@ -99,8 +99,8 @@ def _parse_iso(dtstr: str) -> T.Optional[datetime.datetime]:
 
 
 def strptime_alternative_formats(
-    dtstr: str, formats: T.Sequence[str]
-) -> T.Optional[datetime.datetime]:
+    dtstr: str, formats: list[str]
+) -> datetime.datetime | None:
     for format in formats:
         if format == "ISO":
             dt = _parse_iso(dtstr)
@@ -114,7 +114,7 @@ def strptime_alternative_formats(
     return None
 
 
-def parse_timestr_as_timedelta(timestr: str) -> T.Optional[datetime.timedelta]:
+def parse_timestr_as_timedelta(timestr: str) -> datetime.timedelta | None:
     timestr = timestr.strip()
     parts = timestr.strip().split(":")
     try:
@@ -133,8 +133,8 @@ def parse_timestr_as_timedelta(timestr: str) -> T.Optional[datetime.timedelta]:
 
 
 def parse_time_ratios_as_timedelta(
-    time_tuple: T.Sequence[Ratio],
-) -> T.Optional[datetime.timedelta]:
+    time_tuple: list[Ratio],
+) -> datetime.timedelta | None:
     try:
         hours, minutes, seconds, *_ = time_tuple
     except (ValueError, TypeError):
@@ -156,8 +156,8 @@ def parse_time_ratios_as_timedelta(
 
 def parse_gps_datetime(
     dtstr: str,
-    default_tz: T.Optional[datetime.timezone] = datetime.timezone.utc,
-) -> T.Optional[datetime.datetime]:
+    default_tz: datetime.timezone | None = datetime.timezone.utc,
+) -> datetime.datetime | None:
     dtstr = dtstr.strip()
 
     dt = strptime_alternative_formats(dtstr, ["ISO"])
@@ -176,8 +176,8 @@ def parse_gps_datetime(
 def parse_gps_datetime_separately(
     datestr: str,
     timestr: str,
-    default_tz: T.Optional[datetime.timezone] = datetime.timezone.utc,
-) -> T.Optional[datetime.datetime]:
+    default_tz: datetime.timezone | None = datetime.timezone.utc,
+) -> datetime.datetime | None:
     """
     Parse GPSDateStamp and GPSTimeStamp and return the corresponding datetime object in GMT.
 
@@ -232,8 +232,8 @@ def parse_gps_datetime_separately(
 
 
 def parse_datetimestr_with_subsec_and_offset(
-    dtstr: str, subsec: T.Optional[str] = None, tz_offset: T.Optional[str] = None
-) -> T.Optional[datetime.datetime]:
+    dtstr: str, subsec: str | None = None, tz_offset: str | None = None
+) -> datetime.datetime | None:
     """
     Convert dtstr "YYYY:mm:dd HH:MM:SS[.sss]" to a datetime object.
     It handles time "24:00:00" as "00:00:00" of the next day.
@@ -294,35 +294,35 @@ _FIELD_TYPE = T.TypeVar("_FIELD_TYPE", int, float, str)
 
 class ExifReadABC(abc.ABC):
     @abc.abstractmethod
-    def extract_altitude(self) -> T.Optional[float]:
+    def extract_altitude(self) -> float | None:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def extract_capture_time(self) -> T.Optional[datetime.datetime]:
+    def extract_capture_time(self) -> datetime.datetime | None:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def extract_direction(self) -> T.Optional[float]:
+    def extract_direction(self) -> float | None:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def extract_lon_lat(self) -> T.Optional[T.Tuple[float, float]]:
+    def extract_lon_lat(self) -> tuple[float, float] | None:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def extract_make(self) -> T.Optional[str]:
+    def extract_make(self) -> str | None:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def extract_model(self) -> T.Optional[str]:
+    def extract_model(self) -> str | None:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def extract_width(self) -> T.Optional[int]:
+    def extract_width(self) -> int | None:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def extract_height(self) -> T.Optional[int]:
+    def extract_height(self) -> int | None:
         raise NotImplementedError
 
     @abc.abstractmethod
@@ -333,7 +333,7 @@ class ExifReadABC(abc.ABC):
 class ExifReadFromXMP(ExifReadABC):
     def __init__(self, etree: et.ElementTree):
         self.etree = etree
-        self._tags_or_attrs: T.Dict[str, str] = {}
+        self._tags_or_attrs: dict[str, str] = {}
         for description in self.etree.iterfind(
             ".//rdf:Description", namespaces=XMP_NAMESPACES
         ):
@@ -343,12 +343,12 @@ class ExifReadFromXMP(ExifReadABC):
                 if child.text is not None:
                     self._tags_or_attrs[child.tag] = child.text
 
-    def extract_altitude(self) -> T.Optional[float]:
+    def extract_altitude(self) -> float | None:
         return self._extract_alternative_fields(["exif:GPSAltitude"], float)
 
     def _extract_exif_datetime(
         self, dt_tag: str, subsec_tag: str, offset_tag: str
-    ) -> T.Optional[datetime.datetime]:
+    ) -> datetime.datetime | None:
         dtstr = self._extract_alternative_fields([dt_tag], str)
         if dtstr is None:
             return None
@@ -363,7 +363,7 @@ class ExifReadFromXMP(ExifReadABC):
             return None
         return dt
 
-    def extract_exif_datetime(self) -> T.Optional[datetime.datetime]:
+    def extract_exif_datetime(self) -> datetime.datetime | None:
         dt = self._extract_exif_datetime(
             "exif:DateTimeOriginal",
             "exif:SubsecTimeOriginal",
@@ -382,7 +382,7 @@ class ExifReadFromXMP(ExifReadABC):
 
         return None
 
-    def extract_gps_datetime(self) -> T.Optional[datetime.datetime]:
+    def extract_gps_datetime(self) -> datetime.datetime | None:
         """
         Extract timestamp from GPS field.
         """
@@ -402,7 +402,7 @@ class ExifReadFromXMP(ExifReadABC):
         # handle: exif:GPSTimeStamp="17:22:05.999000"
         return parse_gps_datetime_separately(datestr, timestr)
 
-    def extract_capture_time(self) -> T.Optional[datetime.datetime]:
+    def extract_capture_time(self) -> datetime.datetime | None:
         dt = self.extract_gps_datetime()
         if dt is not None and dt.date() != datetime.date(1970, 1, 1):
             return dt
@@ -413,22 +413,22 @@ class ExifReadFromXMP(ExifReadABC):
 
         return None
 
-    def extract_direction(self) -> T.Optional[float]:
+    def extract_direction(self) -> float | None:
         return self._extract_alternative_fields(
             ["exif:GPSImgDirection", "exif:GPSTrack"], float
         )
 
-    def extract_lon_lat(self) -> T.Optional[T.Tuple[float, float]]:
+    def extract_lon_lat(self) -> tuple[float, float] | None:
         lat_ref = self._extract_alternative_fields(["exif:GPSLatitudeRef"], str)
-        lat_str: T.Optional[str] = self._extract_alternative_fields(
+        lat_str: str | None = self._extract_alternative_fields(
             ["exif:GPSLatitude"], str
         )
-        lat: T.Optional[float] = _parse_coord(lat_str, lat_ref)
+        lat: float | None = _parse_coord(lat_str, lat_ref)
         if lat is None:
             return None
 
         lon_ref = self._extract_alternative_fields(["exif:GPSLongitudeRef"], str)
-        lon_str: T.Optional[str] = self._extract_alternative_fields(
+        lon_str: str | None = self._extract_alternative_fields(
             ["exif:GPSLongitude"], str
         )
         lon = _parse_coord(lon_str, lon_ref)
@@ -437,13 +437,13 @@ class ExifReadFromXMP(ExifReadABC):
 
         return lon, lat
 
-    def extract_make(self) -> T.Optional[str]:
+    def extract_make(self) -> str | None:
         make = self._extract_alternative_fields(["tiff:Make", "exifEX:LensMake"], str)
         if make is None:
             return None
         return make.strip()
 
-    def extract_model(self) -> T.Optional[str]:
+    def extract_model(self) -> str | None:
         model = self._extract_alternative_fields(
             ["tiff:Model", "exifEX:LensModel"], str
         )
@@ -451,7 +451,7 @@ class ExifReadFromXMP(ExifReadABC):
             return None
         return model.strip()
 
-    def extract_width(self) -> T.Optional[int]:
+    def extract_width(self) -> int | None:
         return self._extract_alternative_fields(
             [
                 "exif:PixelXDimension",
@@ -461,7 +461,7 @@ class ExifReadFromXMP(ExifReadABC):
             int,
         )
 
-    def extract_height(self) -> T.Optional[int]:
+    def extract_height(self) -> int | None:
         return self._extract_alternative_fields(
             [
                 "exif:PixelYDimension",
@@ -513,7 +513,7 @@ class ExifReadFromXMP(ExifReadABC):
         return None
 
 
-def extract_xmp_efficiently(fp) -> T.Optional[str]:
+def extract_xmp_efficiently(fp) -> str | None:
     """
     Extract XMP metadata from a JPEG file efficiently by reading only necessary chunks.
 
@@ -598,7 +598,7 @@ class ExifReadFromEXIF(ExifReadABC):
     EXIF class for reading exif from an image
     """
 
-    def __init__(self, path_or_stream: T.Union[Path, T.BinaryIO]) -> None:
+    def __init__(self, path_or_stream: Path | T.BinaryIO) -> None:
         """
         Initialize EXIF object with FILE as filename or fileobj
         """
@@ -621,7 +621,7 @@ class ExifReadFromEXIF(ExifReadABC):
                 LOG.warning("Error reading EXIF: %s", ex)
                 self.tags = {}
 
-    def extract_altitude(self) -> T.Optional[float]:
+    def extract_altitude(self) -> float | None:
         """
         Extract altitude
         """
@@ -634,7 +634,7 @@ class ExifReadFromEXIF(ExifReadABC):
         altitude_ref = {0: 1, 1: -1}
         return altitude * altitude_ref.get(ref, 1)
 
-    def extract_gps_datetime(self) -> T.Optional[datetime.datetime]:
+    def extract_gps_datetime(self) -> datetime.datetime | None:
         """
         Extract timestamp from GPS field.
         """
@@ -662,7 +662,7 @@ class ExifReadFromEXIF(ExifReadABC):
 
     def _extract_exif_datetime(
         self, dt_tag: str, subsec_tag: str, offset_tag: str
-    ) -> T.Optional[datetime.datetime]:
+    ) -> datetime.datetime | None:
         dtstr = self._extract_alternative_fields([dt_tag], field_type=str)
         if dtstr is None:
             return None
@@ -677,7 +677,7 @@ class ExifReadFromEXIF(ExifReadABC):
             return None
         return dt
 
-    def extract_exif_datetime(self) -> T.Optional[datetime.datetime]:
+    def extract_exif_datetime(self) -> datetime.datetime | None:
         # EXIF DateTimeOriginal: 0x9003 (date/time when original image was taken)
         # EXIF SubSecTimeOriginal: 0x9291 (fractional seconds for DateTimeOriginal)
         # EXIF OffsetTimeOriginal: 0x9011 (time zone for DateTimeOriginal)
@@ -711,7 +711,7 @@ class ExifReadFromEXIF(ExifReadABC):
 
         return None
 
-    def extract_capture_time(self) -> T.Optional[datetime.datetime]:
+    def extract_capture_time(self) -> datetime.datetime | None:
         """
         Extract capture time from EXIF DateTime tags
         """
@@ -730,7 +730,7 @@ class ExifReadFromEXIF(ExifReadABC):
 
         return None
 
-    def extract_direction(self) -> T.Optional[float]:
+    def extract_direction(self) -> float | None:
         """
         Extract image direction (i.e. compass, heading, bearing)
         """
@@ -740,7 +740,7 @@ class ExifReadFromEXIF(ExifReadABC):
         ]
         return self._extract_alternative_fields(fields, float)
 
-    def extract_lon_lat(self) -> T.Optional[T.Tuple[float, float]]:
+    def extract_lon_lat(self) -> tuple[float, float] | None:
         lat_tag = self.tags.get("GPS GPSLatitude")
         lon_tag = self.tags.get("GPS GPSLongitude")
         if lat_tag and lon_tag:
@@ -762,7 +762,7 @@ class ExifReadFromEXIF(ExifReadABC):
 
         return None
 
-    def extract_make(self) -> T.Optional[str]:
+    def extract_make(self) -> str | None:
         """
         Extract camera make
         """
@@ -773,7 +773,7 @@ class ExifReadFromEXIF(ExifReadABC):
             return None
         return make.strip()
 
-    def extract_model(self) -> T.Optional[str]:
+    def extract_model(self) -> str | None:
         """
         Extract camera model
         """
@@ -784,7 +784,7 @@ class ExifReadFromEXIF(ExifReadABC):
             return None
         return model.strip()
 
-    def extract_width(self) -> T.Optional[int]:
+    def extract_width(self) -> int | None:
         """
         Extract image width in pixels
         """
@@ -792,7 +792,7 @@ class ExifReadFromEXIF(ExifReadABC):
             ["Image ImageWidth", "EXIF ExifImageWidth"], int
         )
 
-    def extract_height(self) -> T.Optional[int]:
+    def extract_height(self) -> int | None:
         """
         Extract image height in pixels
         """
@@ -813,7 +813,7 @@ class ExifReadFromEXIF(ExifReadABC):
 
     def _extract_alternative_fields(
         self,
-        fields: T.Sequence[str],
+        fields: T.Iterable[str],
         field_type: type[_FIELD_TYPE],
     ) -> _FIELD_TYPE | None:
         """
@@ -847,7 +847,7 @@ class ExifReadFromEXIF(ExifReadABC):
                 raise ValueError(f"Invalid field type {field_type}")
         return None
 
-    def extract_application_notes(self) -> T.Optional[str]:
+    def extract_application_notes(self) -> str | None:
         xmp = self.tags.get("Image ApplicationNotes")
         if xmp is None:
             return None
@@ -863,13 +863,13 @@ class ExifRead(ExifReadFromEXIF):
     NOTE: For performance reasons, XMP is only extracted if EXIF does not contain the required fields
     """
 
-    def __init__(self, path_or_stream: T.Union[Path, T.BinaryIO]) -> None:
+    def __init__(self, path_or_stream: Path | T.BinaryIO) -> None:
         super().__init__(path_or_stream)
         self._path_or_stream = path_or_stream
         self._xml_extracted: bool = False
-        self._cached_xml: T.Optional[ExifReadFromXMP] = None
+        self._cached_xml: ExifReadFromXMP | None = None
 
-    def _xmp_with_reason(self, reason: str) -> T.Optional[ExifReadFromXMP]:
+    def _xmp_with_reason(self, reason: str) -> ExifReadFromXMP | None:
         if not self._xml_extracted:
             LOG.debug('Extracting XMP for "%s"', reason)
             self._cached_xml = self._extract_xmp()
@@ -877,7 +877,7 @@ class ExifRead(ExifReadFromEXIF):
 
         return self._cached_xml
 
-    def _extract_xmp(self) -> T.Optional[ExifReadFromXMP]:
+    def _extract_xmp(self) -> ExifReadFromXMP | None:
         xml_str = self.extract_application_notes()
         if xml_str is None:
             if isinstance(self._path_or_stream, Path):
@@ -898,7 +898,7 @@ class ExifRead(ExifReadFromEXIF):
 
         return ExifReadFromXMP(et.ElementTree(e))
 
-    def extract_altitude(self) -> T.Optional[float]:
+    def extract_altitude(self) -> float | None:
         val = super().extract_altitude()
         if val is not None:
             return val
@@ -910,7 +910,7 @@ class ExifRead(ExifReadFromEXIF):
             return val
         return None
 
-    def extract_capture_time(self) -> T.Optional[datetime.datetime]:
+    def extract_capture_time(self) -> datetime.datetime | None:
         val = super().extract_capture_time()
         if val is not None:
             return val
@@ -922,7 +922,7 @@ class ExifRead(ExifReadFromEXIF):
             return val
         return None
 
-    def extract_lon_lat(self) -> T.Optional[T.Tuple[float, float]]:
+    def extract_lon_lat(self) -> tuple[float, float] | None:
         val = super().extract_lon_lat()
         if val is not None:
             return val
@@ -934,7 +934,7 @@ class ExifRead(ExifReadFromEXIF):
             return val
         return None
 
-    def extract_make(self) -> T.Optional[str]:
+    def extract_make(self) -> str | None:
         val = super().extract_make()
         if val is not None:
             return val
@@ -946,7 +946,7 @@ class ExifRead(ExifReadFromEXIF):
             return val
         return None
 
-    def extract_model(self) -> T.Optional[str]:
+    def extract_model(self) -> str | None:
         val = super().extract_model()
         if val is not None:
             return val
@@ -958,7 +958,7 @@ class ExifRead(ExifReadFromEXIF):
             return val
         return None
 
-    def extract_width(self) -> T.Optional[int]:
+    def extract_width(self) -> int | None:
         val = super().extract_width()
         if val is not None:
             return val
@@ -970,7 +970,7 @@ class ExifRead(ExifReadFromEXIF):
             return val
         return None
 
-    def extract_height(self) -> T.Optional[int]:
+    def extract_height(self) -> int | None:
         val = super().extract_height()
         if val is not None:
             return val