mapillary-tools 0.14.0a2__py3-none-any.whl → 0.14.1__py3-none-any.whl

mapillary_tools/geotag/geotag_videos_from_exiftool.py

@@ -13,6 +13,7 @@ else:
 
 from .. import constants, exceptions, exiftool_read, types
 from ..exiftool_runner import ExiftoolRunner
+from . import options
 from .base import GeotagVideosFromGeneric
 from .utils import index_rdf_description_by_path
 from .video_extractors.exiftool import VideoExifToolExtractor
@@ -22,18 +23,14 @@ LOG = logging.getLogger(__name__)
 
 class GeotagVideosFromExifToolXML(GeotagVideosFromGeneric):
     def __init__(
-        self,
-        xml_path: Path,
-        num_processes: int | None = None,
+        self, source_path: options.SourcePathOption, num_processes: int | None = None
     ):
         super().__init__(num_processes=num_processes)
-        self.xml_path = xml_path
+        self.source_path = source_path
 
     @classmethod
-    def build_image_extractors(
-        cls,
-        rdf_by_path: dict[str, ET.Element],
-        video_paths: T.Iterable[Path],
+    def build_video_extractors_from_etree(
+        cls, rdf_by_path: dict[str, ET.Element], video_paths: T.Iterable[Path]
     ) -> list[VideoExifToolExtractor | types.ErrorMetadata]:
         results: list[VideoExifToolExtractor | types.ErrorMetadata] = []
 
@@ -57,8 +54,49 @@ class GeotagVideosFromExifToolXML(GeotagVideosFromGeneric):
     def _generate_video_extractors(
         self, video_paths: T.Sequence[Path]
     ) -> T.Sequence[VideoExifToolExtractor | types.ErrorMetadata]:
-        rdf_by_path = index_rdf_description_by_path([self.xml_path])
-        return self.build_image_extractors(rdf_by_path, video_paths)
+        rdf_by_path = self.find_rdf_by_path(self.source_path, video_paths)
+        return self.build_video_extractors_from_etree(rdf_by_path, video_paths)
+
+    @classmethod
+    def find_rdf_by_path(
+        cls, option: options.SourcePathOption, paths: T.Iterable[Path]
+    ) -> dict[str, ET.Element]:
+        # Find RDF descriptions by path in RDF description
+        # Sources are matched based on the paths in "rdf:about" in XML elements
+        # {"source_path": "/path/to/exiftool.xml"}
+        # {"source_path": "/path/to/exiftool_xmls/"}
+        if option.source_path is not None:
+            return index_rdf_description_by_path([option.source_path])
+
+        # Find RDF descriptions by pattern matching
+        # i.e. "video.mp4" matches "/path/to/video.xml" regardless of "rdf:about"
+        # {"pattern": "/path/to/%g.xml"}
+        if option.pattern is not None:
+            rdf_by_path = {}
+            for path in paths:
+                canonical_path = exiftool_read.canonical_path(path)
+
+                # Skip non-existent resolved source paths to avoid verbose warnings
+                resolved_source_path = option.resolve(path)
+                if not resolved_source_path.exists():
+                    continue
+
+                rdf_by_about = index_rdf_description_by_path([resolved_source_path])
+                if not rdf_by_about:
+                    continue
+
+                rdf = rdf_by_about.get(canonical_path)
+                if rdf is None:
+                    about, rdf = list(rdf_by_about.items())[0]
+                    if len(rdf_by_about) > 1:
+                        LOG.warning(
+                            f"Found {len(rdf_by_about)} RDFs in the XML source {resolved_source_path}. Using the first RDF (with rdf:about={about}) for {path}"
+                        )
+                rdf_by_path[canonical_path] = rdf
+
+            return rdf_by_path
+
+        raise AssertionError("Either source_path or pattern must be provided")
 
 
 class GeotagVideosFromExifToolRunner(GeotagVideosFromGeneric):
@@ -66,7 +104,10 @@ class GeotagVideosFromExifToolRunner(GeotagVideosFromGeneric):
     def _generate_video_extractors(
         self, video_paths: T.Sequence[Path]
     ) -> T.Sequence[VideoExifToolExtractor | types.ErrorMetadata]:
-        runner = ExiftoolRunner(constants.EXIFTOOL_PATH)
+        if constants.EXIFTOOL_PATH is None:
+            runner = ExiftoolRunner()
+        else:
+            runner = ExiftoolRunner(constants.EXIFTOOL_PATH)
 
         LOG.debug(
             "Extracting XML from %d videos with ExifTool command: %s",
@@ -76,7 +117,13 @@ class GeotagVideosFromExifToolRunner(GeotagVideosFromGeneric):
         try:
             xml = runner.extract_xml(video_paths)
         except FileNotFoundError as ex:
-            raise exceptions.MapillaryExiftoolNotFoundError(ex) from ex
+            exiftool_ex = exceptions.MapillaryExiftoolNotFoundError(ex)
+            return [
+                types.describe_error_metadata(
+                    exiftool_ex, video_path, filetype=types.FileType.VIDEO
+                )
+                for video_path in video_paths
+            ]
 
         try:
             xml_element = ET.fromstring(xml)
@@ -84,7 +131,7 @@ class GeotagVideosFromExifToolRunner(GeotagVideosFromGeneric):
             LOG.warning(
                 "Failed to parse ExifTool XML: %s",
                 str(ex),
-                exc_info=LOG.getEffectiveLevel() <= logging.DEBUG,
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
             )
             rdf_by_path = {}
         else:
@@ -92,6 +139,6 @@ class GeotagVideosFromExifToolRunner(GeotagVideosFromGeneric):
                 xml_element
             )
 
-        return GeotagVideosFromExifToolXML.build_image_extractors(
+        return GeotagVideosFromExifToolXML.build_video_extractors_from_etree(
             rdf_by_path, video_paths
         )

mapillary_tools/geotag/geotag_videos_from_gpx.py

@@ -10,6 +10,7 @@ if sys.version_info >= (3, 12):
 else:
     from typing_extensions import override
 
+from .. import exceptions, types
 from . import options
 from .base import GeotagVideosFromGeneric
 from .video_extractors.gpx import GPXVideoExtractor
@@ -21,19 +22,31 @@ LOG = logging.getLogger(__name__)
 class GeotagVideosFromGPX(GeotagVideosFromGeneric):
     def __init__(
         self,
-        option: options.SourcePathOption | None = None,
+        source_path: options.SourcePathOption | None = None,
         num_processes: int | None = None,
     ):
         super().__init__(num_processes=num_processes)
-        if option is None:
-            option = options.SourcePathOption(pattern="%f.gpx")
-        self.option = option
+        if source_path is None:
+            source_path = options.SourcePathOption(pattern="%g.gpx")
+        self.source_path = source_path
 
     @override
     def _generate_video_extractors(
         self, video_paths: T.Sequence[Path]
-    ) -> T.Sequence[GPXVideoExtractor]:
-        return [
-            GPXVideoExtractor(video_path, self.option.resolve(video_path))
-            for video_path in video_paths
-        ]
+    ) -> T.Sequence[GPXVideoExtractor | types.ErrorMetadata]:
+        results: list[GPXVideoExtractor | types.ErrorMetadata] = []
+        for video_path in video_paths:
+            source_path = self.source_path.resolve(video_path)
+            if source_path.is_file():
+                results.append(GPXVideoExtractor(video_path, source_path))
+            else:
+                results.append(
+                    types.describe_error_metadata(
+                        exceptions.MapillaryVideoGPSNotFoundError(
+                            "GPX file not found for video"
+                        ),
+                        filename=video_path,
+                        filetype=types.FileType.VIDEO,
+                    )
+                )
+        return results

mapillary_tools/geotag/options.py

@@ -60,9 +60,13 @@ class SourceOption:
             elif k == "filetypes":
                 kwargs[k] = {types.FileType(t) for t in v}
             elif k == "source_path":
-                kwargs.setdefault("source_path", SourcePathOption()).source_path = v
+                kwargs.setdefault(
+                    "source_path", SourcePathOption(source_path=Path(v))
+                ).sourthe_path = Path(v)
             elif k == "pattern":
-                kwargs.setdefault("source_path", SourcePathOption()).pattern = v
+                kwargs.setdefault(
+                    "source_path", SourcePathOption(pattern=v)
+                ).pattern = v
             elif k == "interpolation_offset_time":
                 kwargs.setdefault(
                     "interpolation", InterpolationOption()
@@ -85,6 +89,24 @@ class SourcePathOption:
             raise ValueError("Either pattern or source_path must be provided")
 
     def resolve(self, path: Path) -> Path:
+        """
+        Resolve the source path or pattern against the given path.
+
+        Examples:
+            >>> from pathlib import Path
+            >>> opt = SourcePathOption(source_path=Path("/foo/bar.mp4"))
+            >>> opt.resolve(Path("/baz/qux.mp4"))
+            PosixPath('/foo/bar.mp4')
+
+            >>> opt = SourcePathOption(pattern="videos/%g_sub%e")
+            >>> opt.resolve(Path("/data/video1.mp4"))
+            PosixPath('/data/videos/video1_sub.mp4')
+
+            >>> opt = SourcePathOption(pattern="/abs/path/%f")
+            >>> opt.resolve(Path("/tmp/abc.mov"))
+            PosixPath('/abs/path/abc.mov')
+        """
+
         if self.source_path is not None:
             return self.source_path
 
@@ -140,7 +162,7 @@ SourceOptionSchema = {
             "type": "integer",
         },
         "interpolation_offset_time": {
-            "type": "float",
+            "type": "number",
         },
         "interpolation_use_gpx_start_time": {
             "type": "boolean",

mapillary_tools/geotag/utils.py

@@ -37,26 +37,23 @@ def parse_gpx(gpx_file: Path) -> list[Track]:
     return tracks
 
 
-def index_rdf_description_by_path(
-    xml_paths: T.Sequence[Path],
-) -> dict[str, ET.Element]:
-    rdf_description_by_path: dict[str, ET.Element] = {}
+def index_rdf_description_by_path(xml_paths: T.Sequence[Path]) -> dict[str, ET.Element]:
+    rdf_by_path: dict[str, ET.Element] = {}
 
     for xml_path in utils.find_xml_files(xml_paths):
         try:
             etree = ET.parse(xml_path)
-        except ET.ParseError as ex:
-            verbose = LOG.getEffectiveLevel() <= logging.DEBUG
-            if verbose:
-                LOG.warning("Failed to parse %s", xml_path, exc_info=True)
-            else:
-                LOG.warning("Failed to parse %s: %s", xml_path, ex)
+        except Exception as ex:
+            LOG.warning(
+                f"Failed to parse {xml_path}: {ex}",
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
+            )
             continue
 
-        rdf_description_by_path.update(
+        rdf_by_path.update(
             exiftool_read.index_rdf_description_by_path_from_xml_element(
                 etree.getroot()
             )
         )
 
-    return rdf_description_by_path
+    return rdf_by_path

mapillary_tools/geotag/video_extractors/base.py

@@ -14,5 +14,5 @@ class BaseVideoExtractor(abc.ABC):
     def __init__(self, video_path: Path):
         self.video_path = video_path
 
-    def extract(self) -> types.VideoMetadataOrError:
+    def extract(self) -> types.VideoMetadata:
         raise NotImplementedError

mapillary_tools/geotag/video_extractors/exiftool.py

@@ -21,7 +21,7 @@ class VideoExifToolExtractor(BaseVideoExtractor):
         self.element = element
 
     @override
-    def extract(self) -> types.VideoMetadataOrError:
+    def extract(self) -> types.VideoMetadata:
         exif = exiftool_read_video.ExifToolReadVideo(ET.ElementTree(self.element))
 
         make = exif.extract_make()

mapillary_tools/geotag/video_extractors/gpx.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import dataclasses
-import datetime
+import enum
 import logging
 import sys
 import typing as T
@@ -12,7 +12,7 @@ if sys.version_info >= (3, 12):
 else:
     from typing_extensions import override
 
-from ... import geo, telemetry, types
+from ... import exceptions, geo, telemetry, types, utils
 from ..utils import parse_gpx
 from .base import BaseVideoExtractor
 from .native import NativeVideoExtractor
@@ -21,106 +21,97 @@ 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):
+    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.VideoMetadataOrError:
-        try:
-            gpx_tracks = parse_gpx(self.gpx_path)
-        except Exception as ex:
-            raise RuntimeError(
-                f"Error parsing GPX {self.gpx_path}: {ex.__class__.__name__}: {ex}"
-            )
+    def extract(self) -> types.VideoMetadata:
+        gpx_tracks = parse_gpx(self.gpx_path)
 
         if 1 < len(gpx_tracks):
             LOG.warning(
-                "Found %s tracks in the GPX file %s. Will merge points in all the tracks as a single track for interpolation",
-                len(gpx_tracks),
-                self.gpx_path,
+                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)
 
-        video_metadata_or_error = native_extractor.extract()
-
-        if isinstance(video_metadata_or_error, types.ErrorMetadata):
+        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=video_metadata_or_error.filename,
-                filetype=video_metadata_or_error.filetype or types.FileType.VIDEO,
+                filename=self.video_path,
+                filesize=utils.get_file_size(self.video_path),
+                filetype=types.FileType.VIDEO,
                 points=gpx_points,
             )
 
-        video_metadata = video_metadata_or_error
-
-        offset = self._synx_gpx_by_first_gps_timestamp(
-            gpx_points, video_metadata.points
-        )
-
-        self._rebase_times(gpx_points, offset=offset)
+        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(video_metadata_or_error, points=gpx_points)
+        return dataclasses.replace(native_video_metadata, points=gpx_points)
 
-    @staticmethod
-    def _rebase_times(points: T.Sequence[geo.Point], offset: float = 0.0):
+    @classmethod
+    def _rebase_times(cls, points: T.Sequence[geo.Point], offset: float = 0.0) -> None:
         """
-        Make point times start from 0
+        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
-        return points
 
-    def _synx_gpx_by_first_gps_timestamp(
-        self, gpx_points: T.Sequence[geo.Point], video_gps_points: T.Sequence[geo.Point]
+    @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:
-            return offset
-
-        first_gpx_dt = datetime.datetime.fromtimestamp(
-            gpx_points[0].time, tz=datetime.timezone.utc
-        )
-        LOG.info("First GPX timestamp: %s", first_gpx_dt)
-
-        if not video_gps_points:
-            LOG.warning(
-                "Skip GPX synchronization because no GPS found in video %s",
-                self.video_path,
-            )
+        if not gpx_points or not video_gps_points:
             return offset
 
-        first_gps_point = video_gps_points[0]
-        if isinstance(first_gps_point, telemetry.GPSPoint):
-            if first_gps_point.epoch_time is not None:
-                first_gps_dt = datetime.datetime.fromtimestamp(
-                    first_gps_point.epoch_time, tz=datetime.timezone.utc
-                )
-                LOG.info("First GPS timestamp: %s", first_gps_dt)
-                offset = gpx_points[0].time - first_gps_point.epoch_time
-                if offset:
-                    LOG.warning(
-                        "Found offset between GPX %s and video GPS timestamps %s: %s seconds",
-                        first_gpx_dt,
-                        first_gps_dt,
-                        offset,
-                    )
-                else:
-                    LOG.info(
-                        "GPX and GPS are perfectly synchronized (all starts from %s)",
-                        first_gpx_dt,
-                    )
-            else:
-                LOG.warning(
-                    "Skip GPX synchronization because no GPS epoch time found in video %s",
-                    self.video_path,
-                )
+        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

@@ -12,12 +12,13 @@ else:
 from ... import blackvue_parser, exceptions, geo, telemetry, types, utils
 from ...camm import camm_parser
 from ...gpmf import gpmf_gps_filter, gpmf_parser
+from ...mp4 import construct_mp4_parser, simple_mp4_parser
 from .base import BaseVideoExtractor
 
 
 class GoProVideoExtractor(BaseVideoExtractor):
     @override
-    def extract(self) -> types.VideoMetadataOrError:
+    def extract(self) -> types.VideoMetadata:
         with self.video_path.open("rb") as fp:
             gopro_info = gpmf_parser.extract_gopro_info(fp)
 
@@ -29,23 +30,13 @@ class GoProVideoExtractor(BaseVideoExtractor):
         gps_points = gopro_info.gps
         assert gps_points is not None, "must have GPS data extracted"
         if not gps_points:
-            # Instead of raising an exception, return error metadata to tell the file type
-            ex: exceptions.MapillaryDescriptionError = (
-                exceptions.MapillaryGPXEmptyError("Empty GPS data found")
-            )
-            return types.describe_error_metadata(
-                ex, self.video_path, filetype=types.FileType.GOPRO
-            )
+            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:
-            # Instead of raising an exception, return error metadata to tell the file type
-            ex = exceptions.MapillaryGPSNoiseError("GPS is too noisy")
-            return types.describe_error_metadata(
-                ex, self.video_path, filetype=types.FileType.GOPRO
-            )
+            raise exceptions.MapillaryGPSNoiseError("GPS is too noisy")
 
         video_metadata = types.VideoMetadata(
             filename=self.video_path,
@@ -61,7 +52,7 @@ class GoProVideoExtractor(BaseVideoExtractor):
 
 class CAMMVideoExtractor(BaseVideoExtractor):
     @override
-    def extract(self) -> types.VideoMetadataOrError:
+    def extract(self) -> types.VideoMetadata:
         with self.video_path.open("rb") as fp:
             camm_info = camm_parser.extract_camm_info(fp)
 
@@ -71,13 +62,7 @@ class CAMMVideoExtractor(BaseVideoExtractor):
             )
 
         if not camm_info.gps and not camm_info.mini_gps:
-            # Instead of raising an exception, return error metadata to tell the file type
-            ex: exceptions.MapillaryDescriptionError = (
-                exceptions.MapillaryGPXEmptyError("Empty GPS data found")
-            )
-            return types.describe_error_metadata(
-                ex, self.video_path, filetype=types.FileType.CAMM
-            )
+            raise exceptions.MapillaryGPXEmptyError("Empty GPS data found")
 
         return types.VideoMetadata(
             filename=self.video_path,
@@ -91,7 +76,7 @@ class CAMMVideoExtractor(BaseVideoExtractor):
 
 class BlackVueVideoExtractor(BaseVideoExtractor):
     @override
-    def extract(self) -> types.VideoMetadataOrError:
+    def extract(self) -> types.VideoMetadata:
         with self.video_path.open("rb") as fp:
             blackvue_info = blackvue_parser.extract_blackvue_info(fp)
 
@@ -101,19 +86,13 @@ class BlackVueVideoExtractor(BaseVideoExtractor):
             )
 
         if not blackvue_info.gps:
-            # Instead of raising an exception, return error metadata to tell the file type
-            ex: exceptions.MapillaryDescriptionError = (
-                exceptions.MapillaryGPXEmptyError("Empty GPS data found")
-            )
-            return types.describe_error_metadata(
-                ex, self.video_path, filetype=types.FileType.BLACKVUE
-            )
+            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 or [],
+            points=blackvue_info.gps,
             make=blackvue_info.make,
             model=blackvue_info.model,
         )
@@ -127,7 +106,7 @@ class NativeVideoExtractor(BaseVideoExtractor):
         self.filetypes = filetypes
 
     @override
-    def extract(self) -> types.VideoMetadataOrError:
+    def extract(self) -> types.VideoMetadata:
         ft = self.filetypes
         extractor: BaseVideoExtractor
 
@@ -135,6 +114,14 @@ class NativeVideoExtractor(BaseVideoExtractor):
             extractor = GoProVideoExtractor(self.video_path)
             try:
                 return extractor.extract()
+            except simple_mp4_parser.BoxNotFoundError as ex:
+                raise exceptions.MapillaryInvalidVideoError(
+                    f"Invalid video: {ex}"
+                ) from ex
+            except construct_mp4_parser.BoxNotFoundError as ex:
+                raise exceptions.MapillaryInvalidVideoError(
+                    f"Invalid video: {ex}"
+                ) from ex
             except exceptions.MapillaryVideoGPSNotFoundError:
                 pass
 
@@ -142,6 +129,14 @@ class NativeVideoExtractor(BaseVideoExtractor):
             extractor = CAMMVideoExtractor(self.video_path)
             try:
                 return extractor.extract()
+            except simple_mp4_parser.BoxNotFoundError as ex:
+                raise exceptions.MapillaryInvalidVideoError(
+                    f"Invalid video: {ex}"
+                ) from ex
+            except construct_mp4_parser.BoxNotFoundError as ex:
+                raise exceptions.MapillaryInvalidVideoError(
+                    f"Invalid video: {ex}"
+                ) from ex
             except exceptions.MapillaryVideoGPSNotFoundError:
                 pass
 
@@ -149,6 +144,14 @@ class NativeVideoExtractor(BaseVideoExtractor):
             extractor = BlackVueVideoExtractor(self.video_path)
             try:
                 return extractor.extract()
+            except simple_mp4_parser.BoxNotFoundError as ex:
+                raise exceptions.MapillaryInvalidVideoError(
+                    f"Invalid video: {ex}"
+                ) from ex
+            except construct_mp4_parser.BoxNotFoundError as ex:
+                raise exceptions.MapillaryInvalidVideoError(
+                    f"Invalid video: {ex}"
+                ) from ex
             except exceptions.MapillaryVideoGPSNotFoundError:
                 pass