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

mapillary_tools/geotag/video_extractors/gpx.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import dataclasses
+import enum
+import logging
+import sys
+import typing as T
+from pathlib import Path
+
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from typing_extensions import override
+
+from ... import exceptions, geo, telemetry, types
+from ..utils import parse_gpx
+from .base import BaseVideoExtractor
+from .native import NativeVideoExtractor
+
+
+LOG = logging.getLogger(__name__)
+
+
+class SyncMode(enum.Enum):
+    # Sync by video GPS timestamps if found, otherwise rebase
+    SYNC = "sync"
+    # Sync by video GPS timestamps, and throw if not found
+    STRICT_SYNC = "strict_sync"
+    # Rebase all GPX timestamps to start from 0
+    REBASE = "rebase"
+
+
+class GPXVideoExtractor(BaseVideoExtractor):
+    def __init__(
+        self, video_path: Path, gpx_path: Path, sync_mode: SyncMode = SyncMode.SYNC
+    ):
+        self.video_path = video_path
+        self.gpx_path = gpx_path
+        self.sync_mode = sync_mode
+
+    @override
+    def extract(self) -> types.VideoMetadata:
+        gpx_tracks = parse_gpx(self.gpx_path)
+
+        if 1 < len(gpx_tracks):
+            LOG.warning(
+                f"Found {len(gpx_tracks)} tracks in the GPX file {self.gpx_path}. Will merge points in all the tracks as a single track for interpolation"
+            )
+
+        gpx_points: T.Sequence[geo.Point] = sum(gpx_tracks, [])
+
+        native_extractor = NativeVideoExtractor(self.video_path)
+
+        try:
+            native_video_metadata = native_extractor.extract()
+        except exceptions.MapillaryVideoGPSNotFoundError as ex:
+            if self.sync_mode is SyncMode.STRICT_SYNC:
+                raise ex
+            self._rebase_times(gpx_points)
+            return types.VideoMetadata(
+                filename=self.video_path,
+                filetype=types.FileType.VIDEO,
+                points=gpx_points,
+            )
+
+        if self.sync_mode is SyncMode.REBASE:
+            self._rebase_times(gpx_points)
+        else:
+            offset = self._gpx_offset(gpx_points, native_video_metadata.points)
+            self._rebase_times(gpx_points, offset=offset)
+
+        return dataclasses.replace(native_video_metadata, points=gpx_points)
+
+    @classmethod
+    def _rebase_times(cls, points: T.Sequence[geo.Point], offset: float = 0.0) -> None:
+        """
+        Rebase point times to start from **offset**
+        """
+        if points:
+            first_timestamp = points[0].time
+            for p in points:
+                p.time = (p.time - first_timestamp) + offset
+
+    @classmethod
+    def _gpx_offset(
+        cls, gpx_points: T.Sequence[geo.Point], video_gps_points: T.Sequence[geo.Point]
+    ) -> float:
+        """
+        Calculate the offset that needs to be applied to the GPX points to sync with the video GPS points.
+
+        >>> gpx_points = [geo.Point(time=5, lat=1, lon=1, alt=None, angle=None)]
+        >>> GPXVideoExtractor._gpx_offset(gpx_points, gpx_points)
+        0.0
+        >>> GPXVideoExtractor._gpx_offset(gpx_points, [])
+        0.0
+        >>> GPXVideoExtractor._gpx_offset([], gpx_points)
+        0.0
+        """
+        offset: float = 0.0
+
+        if not gpx_points or not video_gps_points:
+            return offset
+
+        gps_epoch_time: float | None = None
+        gps_point = video_gps_points[0]
+        if isinstance(gps_point, telemetry.GPSPoint):
+            if gps_point.epoch_time is not None:
+                gps_epoch_time = gps_point.epoch_time
+        elif isinstance(gps_point, telemetry.CAMMGPSPoint):
+            if gps_point.time_gps_epoch is not None:
+                gps_epoch_time = gps_point.time_gps_epoch
+
+        if gps_epoch_time is not None:
+            offset = gpx_points[0].time - gps_epoch_time
+
+        return offset

mapillary_tools/geotag/video_extractors/native.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import sys
+import typing as T
+from pathlib import Path
+
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from typing_extensions import override
+
+from ... import blackvue_parser, exceptions, geo, telemetry, types, utils
+from ...camm import camm_parser
+from ...gpmf import gpmf_gps_filter, gpmf_parser
+from .base import BaseVideoExtractor
+
+
+class GoProVideoExtractor(BaseVideoExtractor):
+    @override
+    def extract(self) -> types.VideoMetadata:
+        with self.video_path.open("rb") as fp:
+            gopro_info = gpmf_parser.extract_gopro_info(fp)
+
+        if gopro_info is None:
+            raise exceptions.MapillaryVideoGPSNotFoundError(
+                "No GPS data found from the video"
+            )
+
+        gps_points = gopro_info.gps
+        assert gps_points is not None, "must have GPS data extracted"
+        if not gps_points:
+            raise exceptions.MapillaryGPXEmptyError("Empty GPS data found")
+
+        gps_points = T.cast(
+            T.List[telemetry.GPSPoint], gpmf_gps_filter.remove_noisy_points(gps_points)
+        )
+        if not gps_points:
+            raise exceptions.MapillaryGPSNoiseError("GPS is too noisy")
+
+        video_metadata = types.VideoMetadata(
+            filename=self.video_path,
+            filesize=utils.get_file_size(self.video_path),
+            filetype=types.FileType.GOPRO,
+            points=T.cast(T.List[geo.Point], gps_points),
+            make=gopro_info.make,
+            model=gopro_info.model,
+        )
+
+        return video_metadata
+
+
+class CAMMVideoExtractor(BaseVideoExtractor):
+    @override
+    def extract(self) -> types.VideoMetadata:
+        with self.video_path.open("rb") as fp:
+            camm_info = camm_parser.extract_camm_info(fp)
+
+        if camm_info is None:
+            raise exceptions.MapillaryVideoGPSNotFoundError(
+                "No GPS data found from the video"
+            )
+
+        if not camm_info.gps and not camm_info.mini_gps:
+            raise exceptions.MapillaryGPXEmptyError("Empty GPS data found")
+
+        return types.VideoMetadata(
+            filename=self.video_path,
+            filesize=utils.get_file_size(self.video_path),
+            filetype=types.FileType.CAMM,
+            points=T.cast(T.List[geo.Point], camm_info.gps or camm_info.mini_gps),
+            make=camm_info.make,
+            model=camm_info.model,
+        )
+
+
+class BlackVueVideoExtractor(BaseVideoExtractor):
+    @override
+    def extract(self) -> types.VideoMetadata:
+        with self.video_path.open("rb") as fp:
+            blackvue_info = blackvue_parser.extract_blackvue_info(fp)
+
+        if blackvue_info is None:
+            raise exceptions.MapillaryVideoGPSNotFoundError(
+                "No GPS data found from the video"
+            )
+
+        if not blackvue_info.gps:
+            raise exceptions.MapillaryGPXEmptyError("Empty GPS data found")
+
+        video_metadata = types.VideoMetadata(
+            filename=self.video_path,
+            filesize=utils.get_file_size(self.video_path),
+            filetype=types.FileType.BLACKVUE,
+            points=blackvue_info.gps,
+            make=blackvue_info.make,
+            model=blackvue_info.model,
+        )
+
+        return video_metadata
+
+
+class NativeVideoExtractor(BaseVideoExtractor):
+    def __init__(self, video_path: Path, filetypes: set[types.FileType] | None = None):
+        super().__init__(video_path)
+        self.filetypes = filetypes
+
+    @override
+    def extract(self) -> types.VideoMetadata:
+        ft = self.filetypes
+        extractor: BaseVideoExtractor
+
+        if ft is None or types.FileType.VIDEO in ft or types.FileType.GOPRO in ft:
+            extractor = GoProVideoExtractor(self.video_path)
+            try:
+                return extractor.extract()
+            except exceptions.MapillaryVideoGPSNotFoundError:
+                pass
+
+        if ft is None or types.FileType.VIDEO in ft or types.FileType.CAMM in ft:
+            extractor = CAMMVideoExtractor(self.video_path)
+            try:
+                return extractor.extract()
+            except exceptions.MapillaryVideoGPSNotFoundError:
+                pass
+
+        if ft is None or types.FileType.VIDEO in ft or types.FileType.BLACKVUE in ft:
+            extractor = BlackVueVideoExtractor(self.video_path)
+            try:
+                return extractor.extract()
+            except exceptions.MapillaryVideoGPSNotFoundError:
+                pass
+
+        raise exceptions.MapillaryVideoGPSNotFoundError(
+            "No GPS data found from the video"
+        )

mapillary_tools/gpmf/gpmf_parser.py

@@ -39,7 +39,7 @@ class KLVDict(T.TypedDict):
     type: bytes
     structure_size: int
     repeat: int
-    data: T.List[T.Any]
+    data: list[T.Any]
 
 
 GPMFSampleData: C.GreedyRange
@@ -143,7 +143,7 @@ class GoProInfo:
 
 def extract_gopro_info(
     fp: T.BinaryIO, telemetry_only: bool = False
-) -> T.Optional[GoProInfo]:
+) -> GoProInfo | None:
     """
     Return the GoProInfo object if found. None indicates it's not a valid GoPro video.
     """
@@ -276,7 +276,7 @@ def _gps5_timestamp_to_epoch_time(dtstr: str):
 def _gps5_from_stream(
     stream: T.Sequence[KLVDict],
 ) -> T.Generator[telemetry.GPSPoint, None, None]:
-    indexed: T.Dict[bytes, T.List[T.List[T.Any]]] = {
+    indexed: dict[bytes, list[list[T.Any]]] = {
         klv["key"]: klv["data"] for klv in stream
     }
 
@@ -362,7 +362,7 @@ def _gps9_from_stream(
 ) -> T.Generator[telemetry.GPSPoint, None, None]:
     NUM_VALUES = 9
 
-    indexed: T.Dict[bytes, T.List[T.List[T.Any]]] = {
+    indexed: dict[bytes, list[list[T.Any]]] = {
         klv["key"]: klv["data"] for klv in stream
     }
 
@@ -444,8 +444,8 @@ def _find_first_device_id(stream: T.Sequence[KLVDict]) -> int:
     return device_id
 
 
-def _find_first_gps_stream(stream: T.Sequence[KLVDict]) -> T.List[telemetry.GPSPoint]:
-    sample_points: T.List[telemetry.GPSPoint] = []
+def _find_first_gps_stream(stream: T.Sequence[KLVDict]) -> list[telemetry.GPSPoint]:
+    sample_points: list[telemetry.GPSPoint] = []
 
     for klv in stream:
         if klv["key"] == b"STRM":
@@ -469,7 +469,7 @@ def _is_matrix_calibration(matrix: T.Sequence[float]) -> bool:
 
 
 def _build_matrix(
-    orin: T.Union[bytes, T.Sequence[int]], orio: T.Union[bytes, T.Sequence[int]]
+    orin: bytes | T.Sequence[int], orio: bytes | T.Sequence[int]
 ) -> T.Sequence[float]:
     matrix = []
 
@@ -503,14 +503,14 @@ def _apply_matrix(
         yield sum(matrix[row_start + x] * values[x] for x in range(size))
 
 
-def _flatten(nested: T.Sequence[T.Sequence[float]]) -> T.List[float]:
-    output: T.List[float] = []
+def _flatten(nested: T.Sequence[T.Sequence[float]]) -> list[float]:
+    output: list[float] = []
     for row in nested:
         output.extend(row)
     return output
 
 
-def _get_matrix(klv: T.Dict[bytes, KLVDict]) -> T.Optional[T.Sequence[float]]:
+def _get_matrix(klv: dict[bytes, KLVDict]) -> T.Sequence[float] | None:
     mtrx = klv.get(b"MTRX")
     if mtrx is not None:
         matrix: T.Sequence[float] = _flatten(mtrx["data"])
@@ -530,7 +530,7 @@ def _get_matrix(klv: T.Dict[bytes, KLVDict]) -> T.Optional[T.Sequence[float]]:
 def _scale_and_calibrate(
     stream: T.Sequence[KLVDict], key: bytes
 ) -> T.Generator[T.Sequence[float], None, None]:
-    indexed: T.Dict[bytes, KLVDict] = {klv["key"]: klv for klv in stream}
+    indexed: dict[bytes, KLVDict] = {klv["key"]: klv for klv in stream}
 
     klv = indexed.get(key)
     if klv is None:
@@ -561,7 +561,7 @@ def _scale_and_calibrate(
 
 
 def _find_first_telemetry_stream(stream: T.Sequence[KLVDict], key: bytes):
-    values: T.List[T.Sequence[float]] = []
+    values: list[T.Sequence[float]] = []
 
     for klv in stream:
         if klv["key"] == b"STRM":
@@ -684,7 +684,7 @@ def _load_telemetry_from_samples(
     return device_found
 
 
-def _is_gpmd_description(description: T.Dict) -> bool:
+def _is_gpmd_description(description: dict) -> bool:
     return description["format"] == b"gpmd"
 
 
@@ -699,11 +699,11 @@ def _filter_gpmd_samples(track: TrackBoxParser) -> T.Generator[Sample, None, Non
             yield sample
 
 
-def _extract_camera_model_from_devices(device_names: T.Dict[int, bytes]) -> str:
+def _extract_camera_model_from_devices(device_names: dict[int, bytes]) -> str:
     if not device_names:
         return ""
 
-    unicode_names: T.List[str] = []
+    unicode_names: list[str] = []
     for name in device_names.values():
         try:
             unicode_names.append(name.decode("utf-8"))
@@ -730,7 +730,7 @@ def _extract_camera_model_from_devices(device_names: T.Dict[int, bytes]) -> str:
 
 def _iterate_read_sample_data(
     fp: T.BinaryIO, samples: T.Iterable[Sample]
-) -> T.Generator[T.Tuple[Sample, bytes], None, None]:
+) -> T.Generator[tuple[Sample, bytes], None, None]:
     for sample in samples:
         fp.seek(sample.raw_sample.offset, io.SEEK_SET)
         yield (sample, fp.read(sample.raw_sample.size))

mapillary_tools/gpmf/gps_filter.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import statistics
 import typing as T
 
@@ -96,7 +98,7 @@ def both(
 def dbscan(
     sequences: T.Sequence[PointSequence],
     merge_or_not: Decider,
-) -> T.Dict[int, PointSequence]:
+) -> dict[int, PointSequence]:
     """
     One-dimension DBSCAN clustering: https://en.wikipedia.org/wiki/DBSCAN
     The input is a list of sequences, and it is guaranteed that all sequences are sorted by time.
@@ -107,7 +109,7 @@ def dbscan(
     """
 
     # find which sequences (keys) should be merged to which sequences (values)
-    mergeto: T.Dict[int, int] = {}
+    mergeto: dict[int, int] = {}
     for left in range(len(sequences)):
         mergeto.setdefault(left, left)
         # find the first sequence to merge with
@@ -119,7 +121,7 @@ def dbscan(
                 break
 
     # merge
-    merged: T.Dict[int, PointSequence] = {}
+    merged: dict[int, PointSequence] = {}
     for idx, s in enumerate(sequences):
         merged.setdefault(mergeto[idx], []).extend(s)
 

mapillary_tools/history.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import json
 import logging
 import string
@@ -5,6 +7,7 @@ import typing as T
 from pathlib import Path
 
 from . import constants, types
+from .serializer.description import DescriptionJSONSerializer
 
 JSONDict = T.Dict[str, T.Union[str, int, float, None]]
 
@@ -43,18 +46,20 @@ def write_history(
     md5sum: str,
     params: JSONDict,
     summary: JSONDict,
-    metadatas: T.Optional[T.Sequence[types.Metadata]] = None,
+    metadatas: T.Sequence[types.Metadata] | None = None,
 ) -> None:
     if not constants.MAPILLARY_UPLOAD_HISTORY_PATH:
         return
     path = history_desc_path(md5sum)
     LOG.debug("Writing upload history: %s", path)
     path.resolve().parent.mkdir(parents=True, exist_ok=True)
-    history: T.Dict[str, T.Any] = {
+    history: dict[str, T.Any] = {
         "params": params,
         "summary": summary,
     }
     if metadatas is not None:
-        history["descs"] = [types.as_desc(metadata) for metadata in metadatas]
+        history["descs"] = [
+            DescriptionJSONSerializer.as_desc(metadata) for metadata in metadatas
+        ]
     with open(path, "w") as fp:
         fp.write(json.dumps(history))

mapillary_tools/mp4/construct_mp4_parser.py

@@ -1,4 +1,5 @@
 # pyre-ignore-all-errors[5, 16, 21, 58]
+from __future__ import annotations
 
 import typing as T
 
@@ -42,7 +43,7 @@ BoxType = T.Literal[
 
 class BoxDict(T.TypedDict, total=True):
     type: BoxType
-    data: T.Union[T.Sequence["BoxDict"], T.Dict[str, T.Any], bytes]
+    data: T.Sequence["BoxDict"] | dict[str, T.Any] | bytes
 
 
 _UNITY_MATRIX = [0x10000, 0, 0, 0, 0x10000, 0, 0, 0, 0x40000000]
@@ -376,7 +377,7 @@ class Box64ConstructBuilder:
     NOTE: Do not build data with this struct. For building, use Box32StructBuilder instead.
     """
 
-    _box: T.Optional[C.Construct]
+    _box: C.Construct | None
 
     def __init__(
         self,
@@ -438,7 +439,7 @@ class Box64ConstructBuilder:
     def parse_box(self, data: bytes) -> BoxDict:
         return T.cast(BoxDict, self.Box.parse(data))
 
-    def parse_boxlist(self, data: bytes) -> T.List[BoxDict]:
+    def parse_boxlist(self, data: bytes) -> list[BoxDict]:
         return T.cast(T.List[BoxDict], self.BoxList.parse(data))
 
 
@@ -464,7 +465,7 @@ class Box32ConstructBuilder(Box64ConstructBuilder):
     def parse_box(self, data: bytes) -> BoxDict:
         raise NotImplementedError("Box32ConstructBuilder does not support parsing")
 
-    def parse_boxlist(self, data: bytes) -> T.List[BoxDict]:
+    def parse_boxlist(self, data: bytes) -> list[BoxDict]:
         raise NotImplementedError("Box32ConstructBuilder does not support parsing")
 
     def build_box(self, box: BoxDict) -> bytes:
@@ -584,7 +585,7 @@ MOOVWithoutSTBLBuilderConstruct = Box32ConstructBuilder(
 
 
 def find_box_at_pathx(
-    box: T.Union[T.Sequence[BoxDict], BoxDict], path: T.Sequence[bytes]
+    box: T.Sequence[BoxDict] | BoxDict, path: T.Sequence[bytes]
 ) -> BoxDict:
     found = find_box_at_path(box, path)
     if found is None:
@@ -593,8 +594,8 @@ def find_box_at_pathx(
 
 
 def find_box_at_path(
-    box: T.Union[T.Sequence[BoxDict], BoxDict], path: T.Sequence[bytes]
-) -> T.Optional[BoxDict]:
+    box: T.Sequence[BoxDict] | BoxDict, path: T.Sequence[bytes]
+) -> BoxDict | None:
     if not path:
         return None
 
@@ -608,7 +609,7 @@ def find_box_at_path(
         if box["type"] == path[0]:
             if len(path) == 1:
                 return box
-            box_data = T.cast(T.Sequence[BoxDict], box["data"])
+            box_data = T.cast(T.List[BoxDict], box["data"])
             # ListContainer from construct is not sequence
             assert isinstance(box_data, T.Sequence), (
                 f"expect a list of boxes but got {type(box_data)} at path {path}"

mapillary_tools/mp4/mp4_sample_parser.py

@@ -44,16 +44,16 @@ class Sample(T.NamedTuple):
     exact_timedelta: float
 
     # reference to the sample description
-    description: T.Dict
+    description: dict
 
 
 def _extract_raw_samples(
     sizes: T.Sequence[int],
-    chunk_entries: T.Sequence[T.Dict],
+    chunk_entries: T.Sequence[dict],
     chunk_offsets: T.Sequence[int],
     timedeltas: T.Sequence[int],
-    composition_offsets: T.Optional[T.Sequence[int]],
-    syncs: T.Optional[T.Set[int]],
+    composition_offsets: list[int] | None,
+    syncs: set[int] | None,
 ) -> T.Generator[RawSample, None, None]:
     if not sizes:
         return
@@ -130,7 +130,7 @@ def _extract_raw_samples(
 
 def _extract_samples(
     raw_samples: T.Iterator[RawSample],
-    descriptions: T.List,
+    descriptions: list,
     timescale: int,
 ) -> T.Generator[Sample, None, None]:
     acc_delta = 0
@@ -154,21 +154,21 @@ STBLBoxlistConstruct = cparser.Box64ConstructBuilder(
 
 def extract_raw_samples_from_stbl_data(
     stbl: bytes,
-) -> T.Tuple[T.List[T.Dict], T.Generator[RawSample, None, None]]:
-    descriptions = []
-    sizes = []
-    chunk_offsets = []
-    chunk_entries = []
-    timedeltas: T.List[int] = []
-    composition_offsets: T.Optional[T.List[int]] = None
-    syncs: T.Optional[T.Set[int]] = None
+) -> tuple[list[dict], T.Generator[RawSample, None, None]]:
+    descriptions: list[dict] = []
+    sizes: list[int] = []
+    chunk_offsets: list[int] = []
+    chunk_entries: list[dict] = []
+    timedeltas: list[int] = []
+    composition_offsets: list[int] | None = None
+    syncs: set[int] | None = None
 
     stbl_children = T.cast(
         T.Sequence[cparser.BoxDict], STBLBoxlistConstruct.parse(stbl)
     )
 
     for box in stbl_children:
-        data: T.Dict = T.cast(T.Dict, box["data"])
+        data: dict = T.cast(dict, box["data"])
 
         if box["type"] == b"stsd":
             descriptions = list(data["entries"])
@@ -227,32 +227,32 @@ class TrackBoxParser:
         )
         self.stbl_data = T.cast(bytes, stbl["data"])
 
-    def extract_tkhd_boxdata(self) -> T.Dict:
+    def extract_tkhd_boxdata(self) -> dict:
         return T.cast(
-            T.Dict, cparser.find_box_at_pathx(self.trak_children, [b"tkhd"])["data"]
+            dict, cparser.find_box_at_pathx(self.trak_children, [b"tkhd"])["data"]
         )
 
     def is_video_track(self) -> bool:
         hdlr = cparser.find_box_at_pathx(self.trak_children, [b"mdia", b"hdlr"])
         return T.cast(T.Dict[str, T.Any], hdlr["data"])["handler_type"] == b"vide"
 
-    def extract_sample_descriptions(self) -> T.List[T.Dict]:
+    def extract_sample_descriptions(self) -> list[dict]:
         # TODO: return [] if parsing fail
         boxes = _STSDBoxListConstruct.parse(self.stbl_data)
         stsd = cparser.find_box_at_pathx(
             T.cast(T.Sequence[cparser.BoxDict], boxes), [b"stsd"]
         )
-        return T.cast(T.List[T.Dict], T.cast(T.Dict, stsd["data"])["entries"])
+        return T.cast(T.List[dict], T.cast(dict, stsd["data"])["entries"])
 
-    def extract_elst_boxdata(self) -> T.Optional[T.Dict]:
+    def extract_elst_boxdata(self) -> dict | None:
         box = cparser.find_box_at_path(self.trak_children, [b"edts", b"elst"])
         if box is None:
             return None
-        return T.cast(T.Dict, box["data"])
+        return T.cast(dict, box["data"])
 
-    def extract_mdhd_boxdata(self) -> T.Dict:
+    def extract_mdhd_boxdata(self) -> dict:
         box = cparser.find_box_at_pathx(self.trak_children, [b"mdia", b"mdhd"])
-        return T.cast(T.Dict, box["data"])
+        return T.cast(dict, box["data"])
 
     def extract_raw_samples(self) -> T.Generator[RawSample, None, None]:
         _, raw_samples = extract_raw_samples_from_stbl_data(self.stbl_data)
@@ -261,7 +261,7 @@ class TrackBoxParser:
     def extract_samples(self) -> T.Generator[Sample, None, None]:
         descriptions, raw_samples = extract_raw_samples_from_stbl_data(self.stbl_data)
         mdhd = T.cast(
-            T.Dict,
+            dict,
             cparser.find_box_at_pathx(self.trak_children, [b"mdia", b"mdhd"])["data"],
         )
         yield from _extract_samples(raw_samples, descriptions, mdhd["timescale"])
@@ -287,15 +287,15 @@ class MovieBoxParser:
         moov = sparser.parse_box_data_firstx(stream, [b"moov"])
         return cls(moov)
 
-    def extract_mvhd_boxdata(self) -> T.Dict:
+    def extract_mvhd_boxdata(self) -> dict:
         mvhd = cparser.find_box_at_pathx(self.moov_children, [b"mvhd"])
-        return T.cast(T.Dict, mvhd["data"])
+        return T.cast(dict, mvhd["data"])
 
-    def extract_udta_boxdata(self) -> T.Dict | None:
+    def extract_udta_boxdata(self) -> dict | None:
         box = cparser.find_box_at_path(self.moov_children, [b"udta"])
         if box is None:
             return None
-        return T.cast(T.Dict, box["data"])
+        return T.cast(dict, box["data"])
 
     def extract_tracks(self) -> T.Generator[TrackBoxParser, None, None]:
         for box in self.moov_children: