mapillary-tools 0.12.1__py3-none-any.whl → 0.13.1__py3-none-any.whl

mapillary_tools/mp4/mp4_sample_parser.py

@@ -0,0 +1,322 @@
+import datetime
+import typing as T
+from pathlib import Path
+
+from . import construct_mp4_parser as cparser, simple_mp4_parser as sparser
+
+
+class RawSample(T.NamedTuple):
+    # 1-based index
+    description_idx: int
+
+    # sample offset (offset from the beginning of the file)
+    offset: int
+
+    # sample size (in bytes)
+    size: int
+
+    # sample_delta read from stts entries that decides when to decode the sample,
+    # i.e. STTS(n) in the forumula DT(n+1) = DT(n) + STTS(n)
+    # NOTE: timescale is not applied yet (hence int)
+    timedelta: int
+
+    # sample composition offset that decides when to present the sample,
+    # i.e. CTTS(n) in the forumula CT(n) = DT(n) + CTTS(n).
+    # NOTE: timescale is not applied yet (hence int)
+    composition_offset: int
+
+    # if it is a sync sample
+    is_sync: bool
+
+
+class Sample(T.NamedTuple):
+    raw_sample: RawSample
+
+    # accumulated timedelta in seconds, i.e. DT(n) / timescale
+    exact_time: float
+
+    # accumulated composition timedelta in seconds, i.e. CT(n) / timescale
+    exact_composition_time: float
+
+    # exact timedelta in seconds, i.e. STTS(n) / timescale
+    exact_timedelta: float
+
+    # reference to the sample description
+    description: T.Dict
+
+
+def _extract_raw_samples(
+    sizes: T.Sequence[int],
+    chunk_entries: T.Sequence[T.Dict],
+    chunk_offsets: T.Sequence[int],
+    timedeltas: T.Sequence[int],
+    composition_offsets: T.Optional[T.Sequence[int]],
+    syncs: T.Optional[T.Set[int]],
+) -> T.Generator[RawSample, None, None]:
+    if not sizes:
+        return
+
+    if not chunk_entries:
+        return
+
+    assert len(sizes) <= len(timedeltas), (
+        f"got less ({len(timedeltas)}) sample time deltas (stts) than expected ({len(sizes)})"
+    )
+
+    sample_idx = 0
+    chunk_idx = 0
+
+    # iterate compressed chunks
+    for entry_idx, entry in enumerate(chunk_entries):
+        if entry_idx + 1 < len(chunk_entries):
+            nbr_chunks = (
+                chunk_entries[entry_idx + 1]["first_chunk"] - entry["first_chunk"]
+            )
+        else:
+            nbr_chunks = 1
+
+        # iterate chunks
+        for _ in range(nbr_chunks):
+            sample_offset = chunk_offsets[chunk_idx]
+            # iterate samples in this chunk
+            for _ in range(entry["samples_per_chunk"]):
+                is_sync = syncs is None or (sample_idx + 1) in syncs
+                composition_offset = (
+                    composition_offsets[sample_idx]
+                    if composition_offsets is not None
+                    else 0
+                )
+                yield RawSample(
+                    description_idx=entry["sample_description_index"],
+                    offset=sample_offset,
+                    size=sizes[sample_idx],
+                    timedelta=timedeltas[sample_idx],
+                    composition_offset=composition_offset,
+                    is_sync=is_sync,
+                )
+                sample_offset += sizes[sample_idx]
+                sample_idx += 1
+            chunk_idx += 1
+
+    # below handles the single-entry case:
+    # If all the chunks have the same number of samples per chunk
+    # and use the same sample description, this table has one entry.
+
+    # iterate chunks
+    while sample_idx < len(sizes):
+        sample_offset = chunk_offsets[chunk_idx]
+        # iterate samples in this chunk
+        for _ in range(chunk_entries[-1]["samples_per_chunk"]):
+            is_sync = syncs is None or (sample_idx + 1) in syncs
+            composition_offset = (
+                composition_offsets[sample_idx]
+                if composition_offsets is not None
+                else 0
+            )
+            yield RawSample(
+                description_idx=chunk_entries[-1]["sample_description_index"],
+                offset=sample_offset,
+                size=sizes[sample_idx],
+                timedelta=timedeltas[sample_idx],
+                composition_offset=composition_offset,
+                is_sync=is_sync,
+            )
+            sample_offset += sizes[sample_idx]
+            sample_idx += 1
+        chunk_idx += 1
+
+
+def _extract_samples(
+    raw_samples: T.Iterator[RawSample],
+    descriptions: T.List,
+    timescale: int,
+) -> T.Generator[Sample, None, None]:
+    acc_delta = 0
+    for raw_sample in raw_samples:
+        yield Sample(
+            raw_sample=raw_sample,
+            description=descriptions[raw_sample.description_idx - 1],
+            exact_time=acc_delta / timescale,
+            exact_timedelta=raw_sample.timedelta / timescale,
+            # CT(n) = DT(n) + CTTS(n)
+            exact_composition_time=(acc_delta + raw_sample.composition_offset)
+            / timescale,
+        )
+        acc_delta += raw_sample.timedelta
+
+
+STBLBoxlistConstruct = cparser.Box64ConstructBuilder(
+    T.cast(cparser.SwitchMapType, cparser.CMAP[b"stbl"])
+).BoxList
+
+
+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
+
+    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"])
+
+        if box["type"] == b"stsd":
+            descriptions = list(data["entries"])
+        elif box["type"] == b"stsz":
+            if data["sample_size"] == 0:
+                sizes = list(data["entries"])
+            else:
+                sizes = [data["sample_size"] for _ in range(data["sample_count"])]
+        elif box["type"] == b"stco":
+            chunk_offsets = list(data["entries"])
+        elif box["type"] == b"co64":
+            chunk_offsets = list(data["entries"])
+        elif box["type"] == b"stsc":
+            chunk_entries = list(data["entries"])
+        elif box["type"] == b"stts":
+            timedeltas = []
+            for entry in data["entries"]:
+                for _ in range(entry["sample_count"]):
+                    timedeltas.append(entry["sample_delta"])
+        elif box["type"] == b"ctts":
+            composition_offsets = []
+            for entry in data["entries"]:
+                for _ in range(entry["sample_count"]):
+                    composition_offsets.append(entry["sample_offset"])
+        elif box["type"] == b"stss":
+            syncs = set(data["entries"])
+
+    # some stbl have less timedeltas than the sample count i.e. len(sizes),
+    # in this case append 0's to timedeltas
+    while len(timedeltas) < len(sizes):
+        timedeltas.append(0)
+    if composition_offsets is not None:
+        while len(composition_offsets) < len(sizes):
+            composition_offsets.append(0)
+
+    raw_samples = _extract_raw_samples(
+        sizes, chunk_entries, chunk_offsets, timedeltas, composition_offsets, syncs
+    )
+    return descriptions, raw_samples
+
+
+_STSDBoxListConstruct = cparser.Box64ConstructBuilder(
+    # pyre-ignore[6]: pyre does not support recursive type SwitchMapType
+    {b"stsd": cparser.CMAP[b"stsd"]}
+).BoxList
+
+
+class TrackBoxParser:
+    trak_children: T.Sequence[cparser.BoxDict]
+    stbl_data: bytes
+
+    def __init__(self, trak_children: T.Sequence[cparser.BoxDict]):
+        self.trak_children = trak_children
+        stbl = cparser.find_box_at_pathx(
+            self.trak_children, [b"mdia", b"minf", b"stbl"]
+        )
+        self.stbl_data = T.cast(bytes, stbl["data"])
+
+    def extract_tkhd_boxdata(self) -> T.Dict:
+        return T.cast(
+            T.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]:
+        # 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"])
+
+    def extract_elst_boxdata(self) -> T.Optional[T.Dict]:
+        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"])
+
+    def extract_mdhd_boxdata(self) -> T.Dict:
+        box = cparser.find_box_at_pathx(self.trak_children, [b"mdia", b"mdhd"])
+        return T.cast(T.Dict, box["data"])
+
+    def extract_raw_samples(self) -> T.Generator[RawSample, None, None]:
+        _, raw_samples = extract_raw_samples_from_stbl_data(self.stbl_data)
+        yield from raw_samples
+
+    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,
+            cparser.find_box_at_pathx(self.trak_children, [b"mdia", b"mdhd"])["data"],
+        )
+        yield from _extract_samples(raw_samples, descriptions, mdhd["timescale"])
+
+
+class MovieBoxParser:
+    moov_children: T.Sequence[cparser.BoxDict]
+
+    def __init__(self, moov_data: bytes):
+        self.moov_children = T.cast(
+            T.Sequence[cparser.BoxDict],
+            cparser.MOOVWithoutSTBLBuilderConstruct.BoxList.parse(moov_data),
+        )
+
+    @classmethod
+    def parse_file(cls, video_path: Path) -> "MovieBoxParser":
+        with video_path.open("rb") as fp:
+            moov = sparser.parse_box_data_firstx(fp, [b"moov"])
+        return MovieBoxParser(moov)
+
+    @classmethod
+    def parse_stream(cls, stream: T.BinaryIO) -> "MovieBoxParser":
+        moov = sparser.parse_box_data_firstx(stream, [b"moov"])
+        return MovieBoxParser(moov)
+
+    def extract_mvhd_boxdata(self) -> T.Dict:
+        mvhd = cparser.find_box_at_pathx(self.moov_children, [b"mvhd"])
+        return T.cast(T.Dict, mvhd["data"])
+
+    def extract_tracks(self) -> T.Generator[TrackBoxParser, None, None]:
+        for box in self.moov_children:
+            if box["type"] == b"trak":
+                yield TrackBoxParser(T.cast(T.Sequence[cparser.BoxDict], box["data"]))
+
+    def extract_track_at(self, stream_idx: int) -> TrackBoxParser:
+        """
+        stream_idx should be the stream_index specifier. See http://ffmpeg.org/ffmpeg.html#Stream-specifiers-1
+        > Stream numbering is based on the order of the streams as detected by libavformat
+        """
+        trak_boxes = [box for box in self.moov_children if box["type"] == b"trak"]
+        if not (0 <= stream_idx < len(trak_boxes)):
+            raise IndexError(
+                "unable to read stream at %d from the track list (length %d)",
+                stream_idx,
+                len(trak_boxes),
+            )
+        trak_children = T.cast(
+            T.Sequence[cparser.BoxDict], trak_boxes[stream_idx]["data"]
+        )
+        return TrackBoxParser(trak_children)
+
+
+_DT_1904 = datetime.datetime.utcfromtimestamp(0).replace(year=1904)
+
+
+def to_datetime(seconds_since_1904: int) -> datetime.datetime:
+    """
+    Convert seconds since midnight, Jan. 1, 1904, in UTC time
+    """
+    return _DT_1904 + datetime.timedelta(seconds=seconds_since_1904)

mapillary_tools/{geotag → mp4}/simple_mp4_builder.py

@@ -6,11 +6,22 @@ from . import (
     construct_mp4_parser as cparser,
     io_utils,
     mp4_sample_parser as sample_parser,
-    simple_mp4_parser as parser,
+    simple_mp4_parser as sparser,
 )
 from .construct_mp4_parser import BoxDict
 from .mp4_sample_parser import RawSample
 
+"""
+Variable naming conventions:
+
+- *_box: a BoxDict
+- *_children: a list of child BoxDicts under the parent box
+- *_boxdata: BoxDict["data"]
+- *_data: the data in bytes of a box (without the header (type and size))
+- *_typed_data: the data in bytes of a box (with the header (type and size))
+"""
+
+
 UINT32_MAX = 2**32 - 1
 UINT64_MAX = 2**64 - 1
 
@@ -128,6 +139,7 @@ def _build_stts(sample_deltas: T.Iterable[int]) -> BoxDict:
 class _CompressedSampleCompositionOffset:
     __slots__ = ("sample_count", "sample_offset")
     # make sure dataclasses.asdict() produce the result as CompositionTimeToSampleBox expects
+    # SO DO NOT RENAME THE PROPERTIES BELOW
     sample_count: int
     sample_offset: int
 
@@ -225,7 +237,7 @@ _STBLChildrenBuilderConstruct = cparser.Box32ConstructBuilder(
 )
 
 
-def _update_sbtl(trak: BoxDict, sample_offset: int) -> int:
+def _update_sbtl_sample_offsets(trak: BoxDict, sample_offset: int) -> int:
     assert trak["type"] == b"trak"
 
     # new samples with offsets updated
@@ -243,14 +255,13 @@ def _update_sbtl(trak: BoxDict, sample_offset: int) -> int:
         )
         sample_offset += sample.size
     stbl_box = cparser.find_box_at_pathx(trak, [b"trak", b"mdia", b"minf", b"stbl"])
-    descriptions, _ = sample_parser.parse_raw_samples_from_stbl(
-        io.BytesIO(T.cast(bytes, stbl_box["data"]))
+    descriptions, _ = sample_parser.extract_raw_samples_from_stbl_data(
+        T.cast(bytes, stbl_box["data"])
     )
     stbl_children_boxes = build_stbl_from_raw_samples(
         descriptions, repositioned_samples
     )
-    new_stbl_bytes = _STBLChildrenBuilderConstruct.build_boxlist(stbl_children_boxes)
-    stbl_box["data"] = new_stbl_bytes
+    stbl_box["data"] = _STBLChildrenBuilderConstruct.build_boxlist(stbl_children_boxes)
 
     return sample_offset
 
@@ -263,13 +274,13 @@ def iterate_samples(
             stbl_box = cparser.find_box_at_pathx(
                 box, [b"trak", b"mdia", b"minf", b"stbl"]
             )
-            _, raw_samples_iter = sample_parser.parse_raw_samples_from_stbl(
-                io.BytesIO(T.cast(bytes, stbl_box["data"]))
+            _, raw_samples_iter = sample_parser.extract_raw_samples_from_stbl_data(
+                T.cast(bytes, stbl_box["data"])
             )
             yield from raw_samples_iter
 
 
-def _build_mdat_header_bytes(mdat_size: int) -> bytes:
+def _build_mdat_header_data(mdat_size: int) -> bytes:
     if UINT32_MAX < mdat_size + 8:
         return cparser.BoxHeader64.build(
             {
@@ -302,7 +313,7 @@ def find_movie_timescale(moov_children: T.Sequence[BoxDict]) -> int:
     return T.cast(T.Dict, mvhd["data"])["timescale"]
 
 
-def _build_moov_bytes(moov_children: T.Sequence[BoxDict]) -> bytes:
+def _build_moov_typed_data(moov_children: T.Sequence[BoxDict]) -> bytes:
     return cparser.MP4WithoutSTBLBuilderConstruct.build_box(
         {
             "type": b"moov",
@@ -324,62 +335,77 @@ def transform_mp4(
 ) -> io_utils.ChainedIO:
     # extract ftyp
     src_fp.seek(0)
-    source_ftyp_box_data = parser.parse_mp4_data_firstx(src_fp, [b"ftyp"])
-    source_ftyp_data = cparser.MP4WithoutSTBLBuilderConstruct.build_box(
-        {"type": b"ftyp", "data": source_ftyp_box_data}
-    )
+    ftyp_data = sparser.parse_mp4_data_firstx(src_fp, [b"ftyp"])
 
     # extract moov
     src_fp.seek(0)
-    src_moov_data = parser.parse_mp4_data_firstx(src_fp, [b"moov"])
-    moov_children = _MOOVChildrenParserConstruct.parse_boxlist(src_moov_data)
+    moov_data = sparser.parse_mp4_data_firstx(src_fp, [b"moov"])
+    moov_children = _MOOVChildrenParserConstruct.parse_boxlist(moov_data)
 
     # filter tracks in moov
     moov_children = list(_filter_moov_children_boxes(moov_children))
 
     # extract video samples
     source_samples = list(iterate_samples(moov_children))
-    movie_sample_readers = [
+    sample_readers: T.List[io.IOBase] = [
         io_utils.SlicedIO(src_fp, sample.offset, sample.size)
         for sample in source_samples
     ]
     if sample_generator is not None:
-        sample_readers = list(sample_generator(src_fp, moov_children))
-    else:
-        sample_readers = []
+        sample_readers.extend(sample_generator(src_fp, moov_children))
 
     _update_all_trak_tkhd(moov_children)
 
-    # moov_boxes should be immutable since here
+    return build_mp4(ftyp_data, moov_children, sample_readers)
+
+
+def build_mp4(
+    ftyp_data: bytes,
+    moov_children: T.Sequence[BoxDict],
+    sample_readers: T.Iterable[io.IOBase],
+) -> io_utils.ChainedIO:
+    ftyp_typed_data = cparser.MP4WithoutSTBLBuilderConstruct.build_box(
+        {"type": b"ftyp", "data": ftyp_data}
+    )
     mdat_body_size = sum(sample.size for sample in iterate_samples(moov_children))
+    # moov_children should be immutable since here
+    new_moov_typed_data = _rewrite_and_build_moov_typed_data(
+        len(ftyp_typed_data), moov_children
+    )
     return io_utils.ChainedIO(
         [
-            io.BytesIO(source_ftyp_data),
-            io.BytesIO(_rewrite_moov(len(source_ftyp_data), moov_children)),
-            io.BytesIO(_build_mdat_header_bytes(mdat_body_size)),
-            *movie_sample_readers,
+            # ftyp
+            io.BytesIO(ftyp_typed_data),
+            # moov
+            io.BytesIO(new_moov_typed_data),
+            # mdat
+            io.BytesIO(_build_mdat_header_data(mdat_body_size)),
             *sample_readers,
         ]
     )
 
 
-def _rewrite_moov(moov_offset: int, moov_boxes: T.Sequence[BoxDict]) -> bytes:
+def _rewrite_and_build_moov_typed_data(
+    moov_offset: int, moov_children: T.Sequence[BoxDict]
+) -> bytes:
     # build moov for calculating moov size
     sample_offset = 0
-    for box in _filter_trak_boxes(moov_boxes):
-        sample_offset = _update_sbtl(box, sample_offset)
-    moov_data = _build_moov_bytes(moov_boxes)
-    moov_data_size = len(moov_data)
+    for box in _filter_trak_boxes(moov_children):
+        sample_offset = _update_sbtl_sample_offsets(box, sample_offset)
+    moov_typed_data = _build_moov_typed_data(moov_children)
+    moov_typed_data_size = len(moov_typed_data)
 
     # mdat header size
-    mdat_body_size = sum(sample.size for sample in iterate_samples(moov_boxes))
-    mdat_header = _build_mdat_header_bytes(mdat_body_size)
+    mdat_body_size = sum(sample.size for sample in iterate_samples(moov_children))
+    mdat_header_data = _build_mdat_header_data(mdat_body_size)
 
     # build moov for real
-    sample_offset = moov_offset + len(moov_data) + len(mdat_header)
-    for box in _filter_trak_boxes(moov_boxes):
-        sample_offset = _update_sbtl(box, sample_offset)
-    moov_data = _build_moov_bytes(moov_boxes)
-    assert len(moov_data) == moov_data_size, f"{len(moov_data)} != {moov_data_size}"
+    sample_offset = moov_offset + len(moov_typed_data) + len(mdat_header_data)
+    for box in _filter_trak_boxes(moov_children):
+        sample_offset = _update_sbtl_sample_offsets(box, sample_offset)
+    moov_typed_data = _build_moov_typed_data(moov_children)
+    assert len(moov_typed_data) == moov_typed_data_size, (
+        f"{len(moov_typed_data)} != {moov_typed_data_size}"
+    )
 
-    return moov_data
+    return moov_typed_data

mapillary_tools/process_geotag_properties.py

@@ -170,7 +170,7 @@ def _process_videos(
 
 
 def _normalize_import_paths(
-    import_path: T.Union[Path, T.Sequence[Path]]
+    import_path: T.Union[Path, T.Sequence[Path]],
 ) -> T.Sequence[Path]:
     import_paths: T.Sequence[Path]
     if isinstance(import_path, Path):
@@ -206,16 +206,8 @@ def process_geotag_properties(
 
     metadatas: T.List[types.MetadataOrError] = []
 
-    # if more than one filetypes speficied, check filename suffixes,
-    # i.e. files not ended with .jpg or .mp4 will be ignored
-    check_file_suffix = len(filetypes) > 1
-
     if FileType.IMAGE in filetypes:
-        image_paths = utils.find_images(
-            import_paths,
-            skip_subfolders=skip_subfolders,
-            check_file_suffix=check_file_suffix,
-        )
+        image_paths = utils.find_images(import_paths, skip_subfolders=skip_subfolders)
         if image_paths:
             image_metadatas = _process_images(
                 image_paths,
@@ -240,9 +232,7 @@ def process_geotag_properties(
             or FileType.VIDEO in filetypes
         ):
             video_paths = utils.find_videos(
-                import_paths,
-                skip_subfolders=skip_subfolders,
-                check_file_suffix=check_file_suffix,
+                import_paths, skip_subfolders=skip_subfolders
             )
             if video_paths:
                 video_metadata = _process_videos(
@@ -255,9 +245,9 @@ def process_geotag_properties(
                 metadatas.extend(video_metadata)
 
     # filenames should be deduplicated in utils.find_images/utils.find_videos
-    assert len(metadatas) == len(
-        set(metadata.filename for metadata in metadatas)
-    ), "duplicate filenames found"
+    assert len(metadatas) == len(set(metadata.filename for metadata in metadatas)), (
+        "duplicate filenames found"
+    )
 
     return metadatas
 
@@ -283,13 +273,12 @@ def _process_videos_beta(vars_args: T.Dict):
 
     options: CliOptions = {
         "paths": vars_args["import_path"],
-        "recursive": vars_args["skip_subfolders"] == False,
+        "recursive": vars_args["skip_subfolders"] is False,
         "geotag_sources_options": geotag_sources_opts,
         "geotag_source_path": vars_args["geotag_source_path"],
         "num_processes": vars_args["num_processes"],
         "device_make": vars_args["device_make"],
         "device_model": vars_args["device_model"],
-        "check_file_suffix": len(vars_args["filetypes"]) > 1,
     }
     extractor = VideoDataExtractor(options)
     return extractor.process()
@@ -424,19 +413,22 @@ def _show_stats_per_filetype(
     skipped_process_errors: T.Set[T.Type[Exception]],
 ):
     good_metadatas: T.List[T.Union[types.VideoMetadata, types.ImageMetadata]] = []
+    filesize_to_upload = 0
     error_metadatas: T.List[types.ErrorMetadata] = []
     for metadata in metadatas:
         if isinstance(metadata, types.ErrorMetadata):
             error_metadatas.append(metadata)
         else:
             good_metadatas.append(metadata)
+            filesize_to_upload += metadata.filesize or 0
 
     LOG.info("%8d %s(s) read in total", len(metadatas), filetype.value)
     if good_metadatas:
         LOG.info(
-            "\t %8d %s(s) are ready to be uploaded",
+            "\t %8d %s(s) (%s MB) are ready to be uploaded",
             len(good_metadatas),
             filetype.value,
+            round(filesize_to_upload / 1024 / 1024, 1),
         )
 
     error_counter = collections.Counter(
@@ -565,6 +557,8 @@ def process_finalize(
     import_path: T.Union[T.Sequence[Path], Path],
     metadatas: T.List[types.MetadataOrError],
     skip_process_errors: bool = False,
+    device_make: T.Optional[str] = None,
+    device_model: T.Optional[str] = None,
     overwrite_all_EXIF_tags: bool = False,
     overwrite_EXIF_time_tag: bool = False,
     overwrite_EXIF_gps_tag: bool = False,
@@ -575,6 +569,18 @@ def process_finalize(
     desc_path: T.Optional[str] = None,
     num_processes: T.Optional[int] = None,
 ) -> T.List[types.MetadataOrError]:
+    for metadata in metadatas:
+        if isinstance(metadata, types.VideoMetadata):
+            if device_make is not None:
+                metadata.make = device_make
+            if device_model is not None:
+                metadata.model = device_model
+        elif isinstance(metadata, types.ImageMetadata):
+            if device_make is not None:
+                metadata.MAPDeviceMake = device_make
+            if device_model is not None:
+                metadata.MAPDeviceModel = device_model
+
     # modified in place
     _apply_offsets(
         [

mapillary_tools/process_sequence_properties.py

@@ -209,9 +209,9 @@ def _interpolate_subsecs_for_sorting(sequence: PointSequence) -> None:
         gidx = gidx + len(group)
 
     for cur, nxt in geo.pairwise(sequence):
-        assert (
-            cur.time <= nxt.time
-        ), f"sequence must be sorted but got {cur.time} > {nxt.time}"
+        assert cur.time <= nxt.time, (
+            f"sequence must be sorted but got {cur.time} > {nxt.time}"
+        )
 
 
 def _parse_filesize_in_bytes(filesize_str: str) -> int:
@@ -335,9 +335,9 @@ def process_sequence_properties(
 
     results = error_metadatas + image_metadatas + video_metadatas
 
-    assert len(metadatas) == len(
-        results
-    ), f"expected {len(metadatas)} results but got {len(results)}"
+    assert len(metadatas) == len(results), (
+        f"expected {len(metadatas)} results but got {len(results)}"
+    )
     assert sequence_idx == len(
         set(metadata.MAPSequenceUUID for metadata in image_metadatas)
     )