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

mapillary_tools/geotag/base.py

@@ -51,7 +51,7 @@ class GeotagImagesFromGeneric(abc.ABC, T.Generic[TImageExtractor]):
             )
         )
 
-        return results + error_metadatas
+        return T.cast(list[types.ImageMetadataOrError], results + error_metadatas)
 
     # This method is passed to multiprocessing
     # so it has to be classmethod or staticmethod to avoid pickling the instance
@@ -117,7 +117,7 @@ class GeotagVideosFromGeneric(abc.ABC, T.Generic[TVideoExtractor]):
             )
         )
 
-        return results + error_metadatas
+        return T.cast(list[types.VideoMetadataOrError], results + error_metadatas)
 
     # This method is passed to multiprocessing
     # so it has to be classmethod or staticmethod to avoid pickling the instance

mapillary_tools/geotag/factory.py

@@ -6,7 +6,6 @@ import typing as T
 from pathlib import Path
 
 from .. import exceptions, types, utils
-from ..types import FileType
 from . import (
     base,
     geotag_images_from_exif,
@@ -70,8 +69,25 @@ def process(
     for idx, option in enumerate(options):
         LOG.debug("Processing %d files with %s", len(reprocessable_paths), option)
 
-        image_metadata_or_errors = _geotag_images(reprocessable_paths, option)
-        video_metadata_or_errors = _geotag_videos(reprocessable_paths, option)
+        image_videos, video_paths = _filter_images_and_videos(
+            reprocessable_paths, option.filetypes
+        )
+
+        if image_videos:
+            image_geotag = _build_image_geotag(option)
+            image_metadata_or_errors = (
+                image_geotag.to_description(image_videos) if image_geotag else []
+            )
+        else:
+            image_metadata_or_errors = []
+
+        if video_paths:
+            video_geotag = _build_video_geotag(option)
+            video_metadata_or_errors = (
+                video_geotag.to_description(video_paths) if video_geotag else []
+            )
+        else:
+            video_metadata_or_errors = []
 
         more_option = idx < len(options) - 1
 
@@ -97,6 +113,7 @@ def _is_reprocessable(metadata: types.MetadataOrError) -> bool:
             (
                 exceptions.MapillaryGeoTaggingError,
                 exceptions.MapillaryVideoGPSNotFoundError,
+                exceptions.MapillaryExiftoolNotFoundError,
             ),
         ):
             return True
@@ -140,152 +157,144 @@ def _ensure_source_path(option: SourceOption) -> Path:
     return option.source_path.source_path
 
 
-def _geotag_images(
-    paths: T.Iterable[Path], option: SourceOption
-) -> list[types.ImageMetadataOrError]:
-    image_paths, _ = _filter_images_and_videos(paths, option.filetypes)
-
-    if not image_paths:
-        return []
-
+def _build_image_geotag(option: SourceOption) -> base.GeotagImagesFromGeneric | None:
+    """
+    Build a GeotagImagesFromGeneric object based on the provided option.
+    """
     if option.interpolation is None:
         interpolation = InterpolationOption()
     else:
         interpolation = option.interpolation
 
-    geotag: base.GeotagImagesFromGeneric
-
-    if option.source is SourceType.NATIVE:
-        geotag = geotag_images_from_exif.GeotagImagesFromEXIF(
+    if option.source in [SourceType.EXIF, SourceType.NATIVE]:
+        return geotag_images_from_exif.GeotagImagesFromEXIF(
             num_processes=option.num_processes
         )
-        return geotag.to_description(image_paths)
 
     if option.source is SourceType.EXIFTOOL_RUNTIME:
-        geotag = geotag_images_from_exiftool.GeotagImagesFromExifToolRunner(
+        return geotag_images_from_exiftool.GeotagImagesFromExifToolRunner(
             num_processes=option.num_processes
         )
-        try:
-            return geotag.to_description(image_paths)
-        except exceptions.MapillaryExiftoolNotFoundError as ex:
-            LOG.warning('Skip "%s" because: %s', option.source.value, ex)
-            return []
 
     elif option.source is SourceType.EXIFTOOL_XML:
         # This is to ensure 'video_process --geotag={"source": "exiftool_xml", "source_path": "/tmp/xml_path"}'
         # to work
-        geotag = geotag_images_from_exiftool.GeotagImagesFromExifToolWithSamples(
-            xml_path=_ensure_source_path(option),
+        if option.source_path is None:
+            raise exceptions.MapillaryBadParameterError(
+                "source_path must be provided for EXIFTOOL_XML source"
+            )
+        return geotag_images_from_exiftool.GeotagImagesFromExifToolWithSamples(
+            source_path=option.source_path,
             num_processes=option.num_processes,
         )
-        return geotag.to_description(image_paths)
 
     elif option.source is SourceType.GPX:
-        geotag = geotag_images_from_gpx_file.GeotagImagesFromGPXFile(
+        return geotag_images_from_gpx_file.GeotagImagesFromGPXFile(
             source_path=_ensure_source_path(option),
             use_gpx_start_time=interpolation.use_gpx_start_time,
             offset_time=interpolation.offset_time,
             num_processes=option.num_processes,
         )
-        return geotag.to_description(image_paths)
 
     elif option.source is SourceType.NMEA:
-        geotag = geotag_images_from_nmea_file.GeotagImagesFromNMEAFile(
+        return geotag_images_from_nmea_file.GeotagImagesFromNMEAFile(
             source_path=_ensure_source_path(option),
             use_gpx_start_time=interpolation.use_gpx_start_time,
             offset_time=interpolation.offset_time,
             num_processes=option.num_processes,
         )
 
-        return geotag.to_description(image_paths)
-
-    elif option.source is SourceType.EXIF:
-        geotag = geotag_images_from_exif.GeotagImagesFromEXIF(
-            num_processes=option.num_processes
-        )
-        return geotag.to_description(image_paths)
-
-    elif option.source in [
-        SourceType.GOPRO,
-        SourceType.BLACKVUE,
-        SourceType.CAMM,
-    ]:
-        map_geotag_source_to_filetype: dict[SourceType, FileType] = {
-            SourceType.GOPRO: FileType.GOPRO,
-            SourceType.BLACKVUE: FileType.BLACKVUE,
-            SourceType.CAMM: FileType.CAMM,
-        }
-        video_paths = utils.find_videos([_ensure_source_path(option)])
-        image_samples_by_video_path = utils.find_all_image_samples(
-            image_paths, video_paths
-        )
-        video_paths_with_image_samples = list(image_samples_by_video_path.keys())
-        video_metadatas = geotag_videos_from_video.GeotagVideosFromVideo(
-            filetypes={map_geotag_source_to_filetype[option.source]},
-            num_processes=option.num_processes,
-        ).to_description(video_paths_with_image_samples)
-        geotag = geotag_images_from_video.GeotagImagesFromVideo(
-            video_metadatas,
+    elif option.source in [SourceType.GOPRO, SourceType.BLACKVUE, SourceType.CAMM]:
+        return geotag_images_from_video.GeotagImageSamplesFromVideo(
+            _ensure_source_path(option),
             offset_time=interpolation.offset_time,
             num_processes=option.num_processes,
         )
-        return geotag.to_description(image_paths)
 
     else:
         raise ValueError(f"Invalid geotag source {option.source}")
 
 
-def _geotag_videos(
-    paths: T.Iterable[Path], option: SourceOption
-) -> list[types.VideoMetadataOrError]:
-    _, video_paths = _filter_images_and_videos(paths, option.filetypes)
-
-    if not video_paths:
-        return []
-
-    geotag: base.GeotagVideosFromGeneric
+def _build_video_geotag(option: SourceOption) -> base.GeotagVideosFromGeneric | None:
+    """
+    Build a GeotagVideosFromGeneric object based on the provided option.
 
+    Examples:
+        >>> from pathlib import Path
+        >>> from mapillary_tools.geotag.options import SourceOption, SourceType
+        >>> opt = SourceOption(SourceType.NATIVE)
+        >>> geotagger = _build_video_geotag(opt)
+        >>> geotagger.__class__.__name__
+        'GeotagVideosFromVideo'
+
+        >>> opt = SourceOption(SourceType.EXIFTOOL_RUNTIME)
+        >>> geotagger = _build_video_geotag(opt)
+        >>> geotagger.__class__.__name__
+        'GeotagVideosFromExifToolRunner'
+
+        >>> opt = SourceOption(SourceType.EXIFTOOL_XML, source_path=Path("/tmp/test.xml"))
+        >>> geotagger = _build_video_geotag(opt)
+        >>> geotagger.__class__.__name__
+        'GeotagVideosFromExifToolXML'
+
+        >>> opt = SourceOption(SourceType.GPX, source_path=Path("/tmp/test.gpx"))
+        >>> geotagger = _build_video_geotag(opt)
+        >>> geotagger.__class__.__name__
+        'GeotagVideosFromGPX'
+
+        >>> opt = SourceOption(SourceType.NMEA, source_path=Path("/tmp/test.nmea"))
+        >>> _build_video_geotag(opt) is None
+        True
+
+        >>> opt = SourceOption(SourceType.EXIF)
+        >>> _build_video_geotag(opt) is None
+        True
+
+        >>> opt = SourceOption(SourceType.GOPRO)
+        >>> _build_video_geotag(opt) is None
+        True
+
+        >>> try:
+        ...     _build_video_geotag(SourceOption("invalid"))
+        ... except ValueError as e:
+        ...     "Invalid geotag source" in str(e)
+        True
+    """
     if option.source is SourceType.NATIVE:
-        geotag = geotag_videos_from_video.GeotagVideosFromVideo(
+        return geotag_videos_from_video.GeotagVideosFromVideo(
             num_processes=option.num_processes, filetypes=option.filetypes
         )
-        return geotag.to_description(video_paths)
 
     if option.source is SourceType.EXIFTOOL_RUNTIME:
-        geotag = geotag_videos_from_exiftool.GeotagVideosFromExifToolRunner(
+        return geotag_videos_from_exiftool.GeotagVideosFromExifToolRunner(
             num_processes=option.num_processes
         )
-        try:
-            return geotag.to_description(video_paths)
-        except exceptions.MapillaryExiftoolNotFoundError as ex:
-            LOG.warning('Skip "%s" because: %s', option.source.value, ex)
-            return []
 
     elif option.source is SourceType.EXIFTOOL_XML:
-        geotag = geotag_videos_from_exiftool.GeotagVideosFromExifToolXML(
-            xml_path=_ensure_source_path(option),
+        if option.source_path is None:
+            raise exceptions.MapillaryBadParameterError(
+                "source_path must be provided for EXIFTOOL_XML source"
+            )
+        return geotag_videos_from_exiftool.GeotagVideosFromExifToolXML(
+            source_path=option.source_path,
         )
-        return geotag.to_description(video_paths)
 
     elif option.source is SourceType.GPX:
-        geotag = geotag_videos_from_gpx.GeotagVideosFromGPX()
-        return geotag.to_description(video_paths)
+        return geotag_videos_from_gpx.GeotagVideosFromGPX(
+            source_path=option.source_path, num_processes=option.num_processes
+        )
 
     elif option.source is SourceType.NMEA:
         # TODO: geotag videos from NMEA
-        return []
+        return None
 
     elif option.source is SourceType.EXIF:
         # Legacy image-specific geotag types
-        return []
+        return None
 
-    elif option.source in [
-        SourceType.GOPRO,
-        SourceType.BLACKVUE,
-        SourceType.CAMM,
-    ]:
+    elif option.source in [SourceType.GOPRO, SourceType.BLACKVUE, SourceType.CAMM]:
         # Legacy image-specific geotag types
-        return []
+        return None
 
     else:
         raise ValueError(f"Invalid geotag source {option.source}")

mapillary_tools/geotag/geotag_images_from_exiftool.py

@@ -13,29 +13,25 @@ else:
 
 from .. import constants, exceptions, exiftool_read, types, utils
 from ..exiftool_runner import ExiftoolRunner
+from . import options
 from .base import GeotagImagesFromGeneric
 from .geotag_images_from_video import GeotagImagesFromVideo
 from .geotag_videos_from_exiftool import GeotagVideosFromExifToolXML
 from .image_extractors.exiftool import ImageExifToolExtractor
-from .utils import index_rdf_description_by_path
 
 LOG = logging.getLogger(__name__)
 
 
 class GeotagImagesFromExifToolXML(GeotagImagesFromGeneric):
     def __init__(
-        self,
-        xml_path: Path,
-        num_processes: int | None = None,
+        self, source_path: options.SourcePathOption, num_processes: int | None = None
     ):
-        self.xml_path = xml_path
+        self.source_path = source_path
         super().__init__(num_processes=num_processes)
 
     @classmethod
     def build_image_extractors(
-        cls,
-        rdf_by_path: dict[str, ET.Element],
-        image_paths: T.Iterable[Path],
+        cls, rdf_by_path: dict[str, ET.Element], image_paths: T.Iterable[Path]
     ) -> list[ImageExifToolExtractor | types.ErrorMetadata]:
         results: list[ImageExifToolExtractor | types.ErrorMetadata] = []
 
@@ -59,7 +55,9 @@ class GeotagImagesFromExifToolXML(GeotagImagesFromGeneric):
     def _generate_image_extractors(
         self, image_paths: T.Sequence[Path]
     ) -> T.Sequence[ImageExifToolExtractor | types.ErrorMetadata]:
-        rdf_by_path = index_rdf_description_by_path([self.xml_path])
+        rdf_by_path = GeotagVideosFromExifToolXML.find_rdf_by_path(
+            self.source_path, image_paths
+        )
         return self.build_image_extractors(rdf_by_path, image_paths)
 
 
@@ -68,7 +66,10 @@ class GeotagImagesFromExifToolRunner(GeotagImagesFromGeneric):
     def _generate_image_extractors(
         self, image_paths: T.Sequence[Path]
     ) -> T.Sequence[ImageExifToolExtractor | 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 images with ExifTool command: %s",
@@ -78,7 +79,13 @@ class GeotagImagesFromExifToolRunner(GeotagImagesFromGeneric):
         try:
             xml = runner.extract_xml(image_paths)
         except FileNotFoundError as ex:
-            raise exceptions.MapillaryExiftoolNotFoundError(ex) from ex
+            exiftool_ex = exceptions.MapillaryExiftoolNotFoundError(ex)
+            return [
+                types.describe_error_metadata(
+                    exiftool_ex, image_path, filetype=types.FileType.IMAGE
+                )
+                for image_path in image_paths
+            ]
 
         try:
             xml_element = ET.fromstring(xml)
@@ -102,29 +109,30 @@ class GeotagImagesFromExifToolRunner(GeotagImagesFromGeneric):
 class GeotagImagesFromExifToolWithSamples(GeotagImagesFromGeneric):
     def __init__(
         self,
-        xml_path: Path,
+        source_path: options.SourcePathOption,
         offset_time: float = 0.0,
         num_processes: int | None = None,
     ):
         super().__init__(num_processes=num_processes)
-        self.xml_path = xml_path
+        self.source_path = source_path
         self.offset_time = offset_time
 
     def geotag_samples(
         self, image_paths: T.Sequence[Path]
     ) -> list[types.ImageMetadataOrError]:
         # Find all video paths in self.xml_path
-        rdf_by_path = index_rdf_description_by_path([self.xml_path])
+        rdf_by_path = GeotagVideosFromExifToolXML.find_rdf_by_path(
+            self.source_path, image_paths
+        )
         video_paths = utils.find_videos(
-            [Path(pathstr) for pathstr in rdf_by_path.keys()],
+            [Path(canonical_path) for canonical_path in rdf_by_path.keys()],
             skip_subfolders=True,
         )
         # Find all video paths that have sample images
         samples_by_video = utils.find_all_image_samples(image_paths, video_paths)
 
         video_metadata_or_errors = GeotagVideosFromExifToolXML(
-            self.xml_path,
-            num_processes=self.num_processes,
+            self.source_path, num_processes=self.num_processes
         ).to_description(list(samples_by_video.keys()))
         sample_paths = sum(samples_by_video.values(), [])
         sample_metadata_or_errors = GeotagImagesFromVideo(
@@ -146,8 +154,7 @@ class GeotagImagesFromExifToolWithSamples(GeotagImagesFromGeneric):
         non_sample_paths = [path for path in image_paths if path not in sample_paths]
 
         non_sample_metadata_or_errors = GeotagImagesFromExifToolXML(
-            self.xml_path,
-            num_processes=self.num_processes,
+            self.source_path, num_processes=self.num_processes
         ).to_description(non_sample_paths)
 
         return sample_metadata_or_errors + non_sample_metadata_or_errors

mapillary_tools/geotag/geotag_images_from_gpx.py

@@ -12,6 +12,7 @@ else:
     from typing_extensions import override
 
 from .. import exceptions, geo, types
+from ..serializer.description import build_capture_time
 from .base import GeotagImagesFromGeneric
 from .geotag_images_from_exif import ImageEXIFExtractor
 
@@ -19,6 +20,12 @@ from .geotag_images_from_exif import ImageEXIFExtractor
 LOG = logging.getLogger(__name__)
 
 
+class SyncMode:
+    SYNC = "sync"
+    STRICT_SYNC = "strict_sync"
+    RESET = "reset"
+
+
 class GeotagImagesFromGPX(GeotagImagesFromGeneric):
     def __init__(
         self,
@@ -43,26 +50,26 @@ class GeotagImagesFromGPX(GeotagImagesFromGeneric):
 
         if image_metadata.time < sorted_points[0].time:
             delta = sorted_points[0].time - image_metadata.time
-            gpx_start_time = types.datetime_to_map_capture_time(sorted_points[0].time)
-            gpx_end_time = types.datetime_to_map_capture_time(sorted_points[-1].time)
+            gpx_start_time = build_capture_time(sorted_points[0].time)
+            gpx_end_time = build_capture_time(sorted_points[-1].time)
             # with the tolerance of 1ms
             if 0.001 < delta:
                 raise exceptions.MapillaryOutsideGPXTrackError(
                     f"The image date time is {round(delta, 3)} seconds behind the GPX start point",
-                    image_time=types.datetime_to_map_capture_time(image_metadata.time),
+                    image_time=build_capture_time(image_metadata.time),
                     gpx_start_time=gpx_start_time,
                     gpx_end_time=gpx_end_time,
                 )
 
         if sorted_points[-1].time < image_metadata.time:
             delta = image_metadata.time - sorted_points[-1].time
-            gpx_start_time = types.datetime_to_map_capture_time(sorted_points[0].time)
-            gpx_end_time = types.datetime_to_map_capture_time(sorted_points[-1].time)
+            gpx_start_time = build_capture_time(sorted_points[0].time)
+            gpx_end_time = build_capture_time(sorted_points[-1].time)
             # with the tolerance of 1ms
             if 0.001 < delta:
                 raise exceptions.MapillaryOutsideGPXTrackError(
                     f"The image time is {round(delta, 3)} seconds beyond the GPX end point",
-                    image_time=types.datetime_to_map_capture_time(image_metadata.time),
+                    image_time=build_capture_time(image_metadata.time),
                     gpx_start_time=gpx_start_time,
                     gpx_end_time=gpx_end_time,
                 )

mapillary_tools/geotag/geotag_images_from_video.py

@@ -13,6 +13,7 @@ else:
 from .. import types, utils
 from .base import GeotagImagesFromGeneric
 from .geotag_images_from_gpx import GeotagImagesFromGPX
+from .geotag_videos_from_video import GeotagVideosFromVideo
 
 
 LOG = logging.getLogger(__name__)
@@ -90,3 +91,37 @@ class GeotagImagesFromVideo(GeotagImagesFromGeneric):
         assert len(final_image_metadatas) <= len(image_paths)
 
         return final_image_metadatas
+
+
+class GeotagImageSamplesFromVideo(GeotagImagesFromGeneric):
+    def __init__(
+        self,
+        source_path: Path,
+        filetypes: set[types.FileType] | None = None,
+        offset_time: float = 0.0,
+        num_processes: int | None = None,
+    ):
+        super().__init__(num_processes=num_processes)
+        self.source_path = source_path
+        self.filetypes = filetypes
+        self.offset_time = offset_time
+
+    @override
+    def to_description(
+        self, image_paths: T.Sequence[Path]
+    ) -> list[types.ImageMetadataOrError]:
+        video_paths = utils.find_videos([self.source_path])
+        image_samples_by_video_path = utils.find_all_image_samples(
+            image_paths, video_paths
+        )
+        video_paths_with_image_samples = list(image_samples_by_video_path.keys())
+        video_metadatas = GeotagVideosFromVideo(
+            filetypes=self.filetypes,
+            num_processes=self.num_processes,
+        ).to_description(video_paths_with_image_samples)
+        geotag = GeotagImagesFromVideo(
+            video_metadatas,
+            offset_time=self.offset_time,
+            num_processes=self.num_processes,
+        )
+        return geotag.to_description(image_paths)

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,28 @@ 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]:
+        if option.source_path is not None:
+            return index_rdf_description_by_path([option.source_path])
+
+        elif option.pattern is not None:
+            rdf_by_path = {}
+            for path in paths:
+                source_path = option.resolve(path)
+                r = index_rdf_description_by_path([source_path])
+                rdfs = list(r.values())
+                if rdfs:
+                    rdf_by_path[exiftool_read.canonical_path(path)] = rdfs[0]
+            return rdf_by_path
+
+        else:
+            assert False, "Either source_path or pattern must be provided"
 
 
 class GeotagVideosFromExifToolRunner(GeotagVideosFromGeneric):
@@ -66,7 +83,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 +96,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)
@@ -92,6 +118,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