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

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
@@ -43,14 +45,14 @@ 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,
     }

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:

mapillary_tools/mp4/simple_mp4_builder.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import dataclasses
 import io
 import typing as T
@@ -64,8 +66,8 @@ class _SampleChunk:
     offset: int
 
 
-def _build_chunks(raw_samples: T.Iterable[RawSample]) -> T.List[_SampleChunk]:
-    chunks: T.List[_SampleChunk] = []
+def _build_chunks(raw_samples: T.Iterable[RawSample]) -> list[_SampleChunk]:
+    chunks: list[_SampleChunk] = []
     prev_raw_sample = None
 
     for raw_sample in raw_samples:
@@ -120,7 +122,7 @@ class _CompressedSampleDelta:
 
 def _build_stts(sample_deltas: T.Iterable[int]) -> BoxDict:
     # compress deltas
-    compressed: T.List[_CompressedSampleDelta] = []
+    compressed: list[_CompressedSampleDelta] = []
     for delta in sample_deltas:
         if compressed and delta == compressed[-1].sample_delta:
             compressed[-1].sample_count += 1
@@ -146,7 +148,7 @@ class _CompressedSampleCompositionOffset:
 
 def _build_ctts(sample_composition_offsets: T.Iterable[int]) -> BoxDict:
     # compress offsets
-    compressed: T.List[_CompressedSampleCompositionOffset] = []
+    compressed: list[_CompressedSampleCompositionOffset] = []
     for offset in sample_composition_offsets:
         if compressed and offset == compressed[-1].sample_offset:
             compressed[-1].sample_count += 1
@@ -182,7 +184,7 @@ def _build_stss(is_syncs: T.Iterable[bool]) -> BoxDict:
 
 def build_stbl_from_raw_samples(
     descriptions: T.Sequence[T.Any], raw_samples: T.Iterable[RawSample]
-) -> T.List[BoxDict]:
+) -> list[BoxDict]:
     # raw_samples could be iterator so convert to list
     raw_samples = list(raw_samples)
     # It is recommended that the boxes within the Sample Table Box be in the following order:
@@ -329,9 +331,8 @@ _MOOVChildrenParserConstruct = cparser.Box64ConstructBuilder(
 
 def transform_mp4(
     src_fp: T.BinaryIO,
-    sample_generator: T.Optional[
-        T.Callable[[T.BinaryIO, T.List[BoxDict]], T.Iterator[io.IOBase]]
-    ] = None,
+    sample_generator: T.Callable[[T.BinaryIO, list[BoxDict]], T.Iterator[io.IOBase]]
+    | None = None,
 ) -> io_utils.ChainedIO:
     # extract ftyp
     src_fp.seek(0)
@@ -347,7 +348,7 @@ def transform_mp4(
 
     # extract video samples
     source_samples = list(iterate_samples(moov_children))
-    sample_readers: T.List[io.IOBase] = [
+    sample_readers: list[io.IOBase] = [
         io_utils.SlicedIO(src_fp, sample.offset, sample.size)
         for sample in source_samples
     ]

mapillary_tools/mp4/simple_mp4_parser.py

@@ -1,4 +1,5 @@
 # pyre-ignore-all-errors[5, 16, 21, 24, 58]
+from __future__ import annotations
 
 import io
 import typing as T
@@ -130,8 +131,8 @@ def parse_boxes_recursive(
     stream: T.BinaryIO,
     maxsize: int = -1,
     depth: int = 0,
-    box_list_types: T.Optional[T.Set[bytes]] = None,
-) -> T.Generator[T.Tuple[Header, int, T.BinaryIO], None, None]:
+    box_list_types: set[bytes] | None = None,
+) -> T.Generator[tuple[Header, int, T.BinaryIO], None, None]:
     assert maxsize == -1 or 0 <= maxsize
 
     if box_list_types is None:
@@ -152,10 +153,10 @@ def parse_boxes_recursive(
 
 def parse_path(
     stream: T.BinaryIO,
-    path: T.Sequence[T.Union[bytes, T.Sequence[bytes]]],
+    path: T.Sequence[bytes | T.Sequence[bytes]],
     maxsize: int = -1,
     depth: int = 0,
-) -> T.Generator[T.Tuple[Header, T.BinaryIO], None, None]:
+) -> T.Generator[tuple[Header, T.BinaryIO], None, None]:
     if not path:
         return
 
@@ -172,8 +173,8 @@ def parse_path(
 
 
 def _parse_path_first(
-    stream: T.BinaryIO, path: T.List[bytes], maxsize: int = -1, depth: int = 0
-) -> T.Optional[T.Tuple[Header, T.BinaryIO]]:
+    stream: T.BinaryIO, path: list[bytes], maxsize: int = -1, depth: int = 0
+) -> tuple[Header, T.BinaryIO] | None:
     if not path:
         return None
     for h, s in parse_boxes(stream, maxsize=maxsize, extend_eof=depth == 0):
@@ -188,8 +189,8 @@ def _parse_path_first(
 
 
 def parse_mp4_data_first(
-    stream: T.BinaryIO, path: T.List[bytes], maxsize: int = -1
-) -> T.Optional[bytes]:
+    stream: T.BinaryIO, path: list[bytes], maxsize: int = -1
+) -> bytes | None:
     # depth=0 will enable EoF extension
     parsed = _parse_path_first(stream, path, maxsize=maxsize, depth=0)
     if parsed is None:
@@ -199,7 +200,7 @@ def parse_mp4_data_first(
 
 
 def parse_mp4_data_firstx(
-    stream: T.BinaryIO, path: T.List[bytes], maxsize: int = -1
+    stream: T.BinaryIO, path: list[bytes], maxsize: int = -1
 ) -> bytes:
     data = parse_mp4_data_first(stream, path, maxsize=maxsize)
     if data is None:
@@ -208,8 +209,8 @@ def parse_mp4_data_firstx(
 
 
 def parse_box_data_first(
-    stream: T.BinaryIO, path: T.List[bytes], maxsize: int = -1
-) -> T.Optional[bytes]:
+    stream: T.BinaryIO, path: list[bytes], maxsize: int = -1
+) -> bytes | None:
     # depth=1 will disable EoF extension
     parsed = _parse_path_first(stream, path, maxsize=maxsize, depth=1)
     if parsed is None:
@@ -219,7 +220,7 @@ def parse_box_data_first(
 
 
 def parse_box_data_firstx(
-    stream: T.BinaryIO, path: T.List[bytes], maxsize: int = -1
+    stream: T.BinaryIO, path: list[bytes], maxsize: int = -1
 ) -> bytes:
     data = parse_box_data_first(stream, path, maxsize=maxsize)
     if data is None:

mapillary_tools/process_geotag_properties.py

@@ -25,9 +25,7 @@ DEFAULT_GEOTAG_SOURCE_OPTIONS = [
 ]
 
 
-def _normalize_import_paths(
-    import_path: T.Union[Path, T.Sequence[Path]],
-) -> T.Sequence[Path]:
+def _normalize_import_paths(import_path: Path | T.Sequence[Path]) -> T.Sequence[Path]:
     import_paths: T.Sequence[Path]
     if isinstance(import_path, Path):
         import_paths = [import_path]
@@ -219,7 +217,7 @@ def _is_error_skipped(error_type: str, skipped_process_errors: set[T.Type[Except
 
 def _show_stats(
     metadatas: T.Sequence[types.MetadataOrError],
-    skipped_process_errors: T.Set[T.Type[Exception]],
+    skipped_process_errors: set[T.Type[Exception]],
 ) -> None:
     metadatas_by_filetype: dict[types.FileType, list[types.MetadataOrError]] = {}
     for metadata in metadatas:
@@ -249,7 +247,7 @@ def _show_stats(
 def _show_stats_per_filetype(
     metadatas: T.Collection[types.MetadataOrError],
     filetype: types.FileType,
-    skipped_process_errors: T.Set[T.Type[Exception]],
+    skipped_process_errors: set[T.Type[Exception]],
 ):
     good_metadatas: list[types.Metadata]
     good_metadatas, error_metadatas = types.separate_errors(metadatas)
@@ -314,7 +312,7 @@ def _validate_metadatas(
 
 
 def process_finalize(
-    import_path: T.Union[T.Sequence[Path], Path],
+    import_path: T.Sequence[Path] | Path,
     metadatas: list[types.MetadataOrError],
     skip_process_errors: bool = False,
     device_make: str | None = None,
@@ -406,7 +404,7 @@ def process_finalize(
         _write_metadatas(metadatas, desc_path)
 
     # Show stats
-    skipped_process_errors: T.Set[T.Type[Exception]]
+    skipped_process_errors: set[T.Type[Exception]]
     if skip_process_errors:
         # Skip all exceptions
         skipped_process_errors = {Exception}

mapillary_tools/process_sequence_properties.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import itertools
 import logging
 import math
@@ -14,13 +16,13 @@ PointSequence = T.List[geo.PointLike]
 
 
 def split_sequence_by(
-    sequence: T.List[SeqItem],
+    sequence: T.Sequence[SeqItem],
     should_split: T.Callable[[SeqItem, SeqItem], bool],
-) -> T.List[T.List[SeqItem]]:
+) -> list[list[SeqItem]]:
     """
     Split a sequence into multiple sequences by should_split(prev, cur) => True
     """
-    output_sequences: T.List[T.List[SeqItem]] = []
+    output_sequences: list[list[SeqItem]] = []
 
     seq = iter(sequence)
 
@@ -45,14 +47,14 @@ def split_sequence_by(
 
 
 def split_sequence_by_agg(
-    sequence: T.List[SeqItem],
-    should_split_with_sequence_state: T.Callable[[SeqItem, T.Dict], bool],
-) -> T.List[T.List[SeqItem]]:
+    sequence: T.Sequence[SeqItem],
+    should_split_with_sequence_state: T.Callable[[SeqItem, dict], bool],
+) -> list[list[SeqItem]]:
     """
     Split a sequence by should_split_with_sequence_state(cur, sequence_state) => True
     """
-    output_sequences: T.List[T.List[SeqItem]] = []
-    sequence_state: T.Dict = {}
+    output_sequences: list[list[SeqItem]] = []
+    sequence_state: dict = {}
 
     for cur in sequence:
         start_new_sequence = should_split_with_sequence_state(cur, sequence_state)
@@ -77,9 +79,9 @@ def duplication_check(
     sequence: PointSequence,
     max_duplicate_distance: float,
     max_duplicate_angle: float,
-) -> T.Tuple[PointSequence, T.List[types.ErrorMetadata]]:
+) -> tuple[PointSequence, list[types.ErrorMetadata]]:
     dedups: PointSequence = []
-    dups: T.List[types.ErrorMetadata] = []
+    dups: list[types.ErrorMetadata] = []
 
     it = iter(sequence)
     prev = next(it)
@@ -125,10 +127,10 @@ def duplication_check(
 
 
 def _group_by(
-    image_metadatas: T.List[types.ImageMetadata],
+    image_metadatas: T.Iterable[types.ImageMetadata],
     group_key_func=T.Callable[[types.ImageMetadata], T.Hashable],
-) -> T.Dict[T.Hashable, T.List[types.ImageMetadata]]:
-    grouped: T.Dict[T.Hashable, T.List[types.ImageMetadata]] = {}
+) -> dict[T.Hashable, list[types.ImageMetadata]]:
+    grouped: dict[T.Hashable, list[types.ImageMetadata]] = {}
     for metadata in image_metadatas:
         grouped.setdefault(group_key_func(metadata), []).append(metadata)
     return grouped
@@ -245,13 +247,13 @@ def _is_video_stationary(
 
 
 def _check_video_limits(
-    video_metadatas: T.Sequence[types.VideoMetadata],
+    video_metadatas: T.Iterable[types.VideoMetadata],
     max_sequence_filesize_in_bytes: int,
     max_avg_speed: float,
     max_radius_for_stationary_check: float,
-) -> T.Tuple[T.List[types.VideoMetadata], T.List[types.ErrorMetadata]]:
-    output_video_metadatas: T.List[types.VideoMetadata] = []
-    error_metadatas: T.List[types.ErrorMetadata] = []
+) -> tuple[list[types.VideoMetadata], list[types.ErrorMetadata]]:
+    output_video_metadatas: list[types.VideoMetadata] = []
+    error_metadatas: list[types.ErrorMetadata] = []
 
     for video_metadata in video_metadatas:
         try:
@@ -312,9 +314,9 @@ def _check_sequences_by_limits(
     input_sequences: T.Sequence[PointSequence],
     max_sequence_filesize_in_bytes: int,
     max_avg_speed: float,
-) -> T.Tuple[T.List[PointSequence], T.List[types.ErrorMetadata]]:
-    output_sequences: T.List[PointSequence] = []
-    output_errors: T.List[types.ErrorMetadata] = []
+) -> tuple[list[PointSequence], list[types.ErrorMetadata]]:
+    output_sequences: list[PointSequence] = []
+    output_errors: list[types.ErrorMetadata] = []
 
     for sequence in input_sequences:
         sequence_filesize = sum(
@@ -370,8 +372,8 @@ def _check_sequences_by_limits(
 
 
 def _group_by_folder_and_camera(
-    image_metadatas: T.List[types.ImageMetadata],
-) -> T.List[T.List[types.ImageMetadata]]:
+    image_metadatas: list[types.ImageMetadata],
+) -> list[list[types.ImageMetadata]]:
     grouped = _group_by(
         image_metadatas,
         lambda metadata: (
@@ -395,8 +397,8 @@ def _group_by_folder_and_camera(
 
 
 def _split_sequences_by_cutoff_time(
-    input_sequences: T.List[PointSequence], cutoff_time: float
-) -> T.List[PointSequence]:
+    input_sequences: T.Sequence[PointSequence], cutoff_time: float
+) -> list[PointSequence]:
     def _should_split_by_cutoff_time(
         prev: types.ImageMetadata, cur: types.ImageMetadata
     ) -> bool:
@@ -432,8 +434,8 @@ def _split_sequences_by_cutoff_time(
 
 
 def _split_sequences_by_cutoff_distance(
-    input_sequences: T.List[PointSequence], cutoff_distance: float
-) -> T.List[PointSequence]:
+    input_sequences: T.Sequence[PointSequence], cutoff_distance: float
+) -> list[PointSequence]:
     def _should_split_by_cutoff_distance(
         prev: types.ImageMetadata, cur: types.ImageMetadata
     ) -> bool:
@@ -471,12 +473,12 @@ def _split_sequences_by_cutoff_distance(
 
 
 def _check_sequences_duplication(
-    input_sequences: T.List[PointSequence],
+    input_sequences: T.Sequence[PointSequence],
     duplicate_distance: float,
     duplicate_angle: float,
-) -> T.Tuple[T.List[PointSequence], T.List[types.ErrorMetadata]]:
-    output_sequences: T.List[PointSequence] = []
-    output_errors: T.List[types.ErrorMetadata] = []
+) -> tuple[list[PointSequence], list[types.ErrorMetadata]]:
+    output_sequences: list[PointSequence] = []
+    output_errors: list[types.ErrorMetadata] = []
 
     for sequence in input_sequences:
         output_sequence, errors = duplication_check(
@@ -502,14 +504,14 @@ def _check_sequences_duplication(
 
 
 def _split_sequences_by_limits(
-    input_sequences: T.List[PointSequence],
+    input_sequences: T.Sequence[PointSequence],
     max_sequence_filesize_in_bytes: float,
     max_sequence_pixels: float,
-) -> T.List[PointSequence]:
+) -> list[PointSequence]:
     max_sequence_images = constants.MAX_SEQUENCE_LENGTH
     max_sequence_filesize = max_sequence_filesize_in_bytes
 
-    def _should_split(image: types.ImageMetadata, sequence_state: T.Dict) -> bool:
+    def _should_split(image: types.ImageMetadata, sequence_state: dict) -> bool:
         last_sequence_images = sequence_state.get("last_sequence_images", 0)
         last_sequence_file_size = sequence_state.get("last_sequence_file_size", 0)
         last_sequence_pixels = sequence_state.get("last_sequence_pixels", 0)
@@ -586,15 +588,15 @@ def process_sequence_properties(
     duplicate_distance: float = constants.DUPLICATE_DISTANCE,
     duplicate_angle: float = constants.DUPLICATE_ANGLE,
     max_avg_speed: float = constants.MAX_AVG_SPEED,
-) -> T.List[types.MetadataOrError]:
+) -> list[types.MetadataOrError]:
     max_sequence_filesize_in_bytes = _parse_filesize_in_bytes(
         constants.MAX_SEQUENCE_FILESIZE
     )
     max_sequence_pixels = _parse_pixels(constants.MAX_SEQUENCE_PIXELS)
 
-    error_metadatas: T.List[types.ErrorMetadata] = []
-    image_metadatas: T.List[types.ImageMetadata] = []
-    video_metadatas: T.List[types.VideoMetadata] = []
+    error_metadatas: list[types.ErrorMetadata] = []
+    image_metadatas: list[types.ImageMetadata] = []
+    video_metadatas: list[types.VideoMetadata] = []
 
     for metadata in metadatas:
         if isinstance(metadata, types.ErrorMetadata):
@@ -617,7 +619,7 @@ def process_sequence_properties(
         error_metadatas.extend(video_error_metadatas)
 
     if image_metadatas:
-        sequences: T.List[PointSequence]
+        sequences: list[PointSequence]
 
         # Group by folder and camera
         sequences = _group_by_folder_and_camera(image_metadatas)