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

mapillary_tools/geotag/geotag_from_generic.py

@@ -1,22 +1,163 @@
+from __future__ import annotations
+
 import abc
+import logging
 import typing as T
+from pathlib import Path
+
+from tqdm import tqdm
+
+from .. import exceptions, types, utils
+
+
+LOG = logging.getLogger(__name__)
+
+
+class GenericImageExtractor(abc.ABC):
+    """
+    Extracts metadata from an image file.
+    """
+
+    def __init__(self, image_path: Path):
+        self.image_path = image_path
+
+    def extract(self) -> types.ImageMetadataOrError:
+        raise NotImplementedError
+
+
+TImageExtractor = T.TypeVar("TImageExtractor", bound=GenericImageExtractor)
+
+
+class GeotagImagesFromGeneric(abc.ABC, T.Generic[TImageExtractor]):
+    """
+    Extracts metadata from a list of image files with multiprocessing.
+    """
+
+    def __init__(
+        self, image_paths: T.Sequence[Path], num_processes: int | None = None
+    ) -> None:
+        self.image_paths = image_paths
+        self.num_processes = num_processes
+
+    def to_description(self) -> list[types.ImageMetadataOrError]:
+        extractor_or_errors = self._generate_image_extractors()
+
+        assert len(extractor_or_errors) == len(self.image_paths)
+
+        extractors, error_metadatas = types.separate_errors(extractor_or_errors)
 
-from .. import types
+        map_results = utils.mp_map_maybe(
+            self.run_extraction,
+            extractors,
+            num_processes=self.num_processes,
+        )
 
+        results = list(
+            tqdm(
+                map_results,
+                desc="Extracting images",
+                unit="images",
+                disable=LOG.getEffectiveLevel() <= logging.DEBUG,
+                total=len(extractors),
+            )
+        )
 
-class GeotagImagesFromGeneric(abc.ABC):
-    def __init__(self) -> None:
-        pass
+        return results + error_metadatas
 
-    @abc.abstractmethod
-    def to_description(self) -> T.List[types.ImageMetadataOrError]:
+    def _generate_image_extractors(
+        self,
+    ) -> T.Sequence[TImageExtractor | types.ErrorMetadata]:
         raise NotImplementedError
 
+    # This method is passed to multiprocessing
+    # so it has to be classmethod or staticmethod to avoid pickling the instance
+    @classmethod
+    def run_extraction(cls, extractor: TImageExtractor) -> types.ImageMetadataOrError:
+        image_path = extractor.image_path
 
-class GeotagVideosFromGeneric(abc.ABC):
-    def __init__(self) -> None:
-        pass
+        try:
+            return extractor.extract()
+        except exceptions.MapillaryDescriptionError as ex:
+            return types.describe_error_metadata(
+                ex, image_path, filetype=types.FileType.IMAGE
+            )
+        except Exception as ex:
+            LOG.exception("Unexpected error extracting metadata from %s", image_path)
+            return types.describe_error_metadata(
+                ex, image_path, filetype=types.FileType.IMAGE
+            )
 
-    @abc.abstractmethod
-    def to_description(self) -> T.List[types.VideoMetadataOrError]:
+
+class GenericVideoExtractor(abc.ABC):
+    """
+    Extracts metadata from a video file.
+    """
+
+    def __init__(self, video_path: Path):
+        self.video_path = video_path
+
+    def extract(self) -> types.VideoMetadataOrError:
+        raise NotImplementedError
+
+
+TVideoExtractor = T.TypeVar("TVideoExtractor", bound=GenericVideoExtractor)
+
+
+class GeotagVideosFromGeneric(abc.ABC, T.Generic[TVideoExtractor]):
+    """
+    Extracts metadata from a list of video files with multiprocessing.
+    """
+
+    def __init__(
+        self, video_paths: T.Sequence[Path], num_processes: int | None = None
+    ) -> None:
+        self.video_paths = video_paths
+        self.num_processes = num_processes
+
+    def to_description(self) -> list[types.VideoMetadataOrError]:
+        extractor_or_errors = self._generate_video_extractors()
+
+        assert len(extractor_or_errors) == len(self.video_paths)
+
+        extractors, error_metadatas = types.separate_errors(extractor_or_errors)
+
+        map_results = utils.mp_map_maybe(
+            self.run_extraction,
+            extractors,
+            num_processes=self.num_processes,
+        )
+
+        results = list(
+            tqdm(
+                map_results,
+                desc="Extracting videos",
+                unit="videos",
+                disable=LOG.getEffectiveLevel() <= logging.DEBUG,
+                total=len(extractors),
+            )
+        )
+
+        return results + error_metadatas
+
+    def _generate_video_extractors(
+        self,
+    ) -> T.Sequence[TVideoExtractor | types.ErrorMetadata]:
         raise NotImplementedError
+
+    # This method is passed to multiprocessing
+    # so it has to be classmethod or staticmethod to avoid pickling the instance
+    @classmethod
+    def run_extraction(cls, extractor: TVideoExtractor) -> types.VideoMetadataOrError:
+        video_path = extractor.video_path
+
+        try:
+            return extractor.extract()
+        except exceptions.MapillaryDescriptionError as ex:
+            return types.describe_error_metadata(
+                ex, video_path, filetype=types.FileType.VIDEO
+            )
+        except Exception as ex:
+            LOG.exception("Unexpected error extracting metadata from %s", video_path)
+            return types.describe_error_metadata(
+                ex, video_path, filetype=types.FileType.VIDEO
+            )

mapillary_tools/geotag/geotag_images_from_exif.py

@@ -1,141 +1,60 @@
-import io
+import contextlib
 import logging
 import typing as T
-from multiprocessing import Pool
 from pathlib import Path
 
-from tqdm import tqdm
-
-from .. import exceptions, exif_write, geo, types, utils
+from .. import exceptions, geo, types, utils
 from ..exif_read import ExifRead, ExifReadABC
-from .geotag_from_generic import GeotagImagesFromGeneric
+from .geotag_from_generic import GenericImageExtractor, GeotagImagesFromGeneric
 
 LOG = logging.getLogger(__name__)
 
 
-def verify_image_exif_write(
-    metadata: types.ImageMetadata,
-    image_bytes: T.Optional[bytes] = None,
-) -> None:
-    if image_bytes is None:
-        edit = exif_write.ExifEdit(metadata.filename)
-    else:
-        edit = exif_write.ExifEdit(image_bytes)
-
-    # The cast is to fix the type error in Python3.6:
-    # Argument 1 to "add_image_description" of "ExifEdit" has incompatible type "ImageDescription"; expected "Dict[str, Any]"
-    edit.add_image_description(
-        T.cast(T.Dict, types.desc_file_to_exif(types.as_desc(metadata)))
-    )
-
-    # Possible errors thrown here:
-    # - struct.error: 'H' format requires 0 <= number <= 65535
-    # - piexif.InvalidImageDataError
-    edit.dump_image_bytes()
-
-
-class GeotagImagesFromEXIF(GeotagImagesFromGeneric):
-    def __init__(
-        self, image_paths: T.Sequence[Path], num_processes: T.Optional[int] = None
-    ):
-        self.image_paths = image_paths
-        self.num_processes = num_processes
-        super().__init__()
-
-    @staticmethod
-    def build_image_metadata(
-        image_path: Path, exif: ExifReadABC, skip_lonlat_error: bool = False
-    ) -> types.ImageMetadata:
-        lonlat = exif.extract_lon_lat()
-        if lonlat is None:
-            if not skip_lonlat_error:
+class ImageEXIFExtractor(GenericImageExtractor):
+    def __init__(self, image_path: Path, skip_lonlat_error: bool = False):
+        super().__init__(image_path)
+        self.skip_lonlat_error = skip_lonlat_error
+
+    @contextlib.contextmanager
+    def _exif_context(self) -> T.Generator[ExifReadABC, None, None]:
+        with self.image_path.open("rb") as fp:
+            yield ExifRead(fp)
+
+    def extract(self) -> types.ImageMetadata:
+        with self._exif_context() as exif:
+            lonlat = exif.extract_lon_lat()
+            if lonlat is None:
+                if not self.skip_lonlat_error:
+                    raise exceptions.MapillaryGeoTaggingError(
+                        "Unable to extract GPS Longitude or GPS Latitude from the image"
+                    )
+                lonlat = (0.0, 0.0)
+            lon, lat = lonlat
+
+            capture_time = exif.extract_capture_time()
+            if capture_time is None:
                 raise exceptions.MapillaryGeoTaggingError(
-                    "Unable to extract GPS Longitude or GPS Latitude from the image"
+                    "Unable to extract timestamp from the image"
                 )
-            lonlat = (0.0, 0.0)
-        lon, lat = lonlat
 
-        capture_time = exif.extract_capture_time()
-        if capture_time is None:
-            raise exceptions.MapillaryGeoTaggingError(
-                "Unable to extract timestamp from the image"
+            image_metadata = types.ImageMetadata(
+                filename=self.image_path,
+                filesize=utils.get_file_size(self.image_path),
+                time=geo.as_unix_time(capture_time),
+                lat=lat,
+                lon=lon,
+                alt=exif.extract_altitude(),
+                angle=exif.extract_direction(),
+                width=exif.extract_width(),
+                height=exif.extract_height(),
+                MAPOrientation=exif.extract_orientation(),
+                MAPDeviceMake=exif.extract_make(),
+                MAPDeviceModel=exif.extract_model(),
             )
 
-        image_metadata = types.ImageMetadata(
-            filename=image_path,
-            md5sum=None,
-            filesize=utils.get_file_size(image_path),
-            time=geo.as_unix_time(capture_time),
-            lat=lat,
-            lon=lon,
-            alt=exif.extract_altitude(),
-            angle=exif.extract_direction(),
-            width=exif.extract_width(),
-            height=exif.extract_height(),
-            MAPOrientation=exif.extract_orientation(),
-            MAPDeviceMake=exif.extract_make(),
-            MAPDeviceModel=exif.extract_model(),
-        )
-
         return image_metadata
 
-    @staticmethod
-    def geotag_image(
-        image_path: Path, skip_lonlat_error: bool = False
-    ) -> types.ImageMetadataOrError:
-        try:
-            # load the image bytes into memory to avoid reading it multiple times
-            with image_path.open("rb") as fp:
-                image_bytesio = io.BytesIO(fp.read())
-
-            image_bytesio.seek(0, io.SEEK_SET)
-            exif = ExifRead(image_bytesio)
 
-            image_metadata = GeotagImagesFromEXIF.build_image_metadata(
-                image_path, exif, skip_lonlat_error=skip_lonlat_error
-            )
-
-            image_bytesio.seek(0, io.SEEK_SET)
-            verify_image_exif_write(
-                image_metadata,
-                image_bytes=image_bytesio.read(),
-            )
-        except Exception as ex:
-            return types.describe_error_metadata(
-                ex, image_path, filetype=types.FileType.IMAGE
-            )
-
-        image_bytesio.seek(0, io.SEEK_SET)
-        image_metadata.update_md5sum(image_bytesio)
-
-        return image_metadata
-
-    def to_description(self) -> T.List[types.ImageMetadataOrError]:
-        if self.num_processes is None:
-            num_processes = self.num_processes
-            disable_multiprocessing = False
-        else:
-            num_processes = max(self.num_processes, 1)
-            disable_multiprocessing = self.num_processes <= 0
-
-        with Pool(processes=num_processes) as pool:
-            image_metadatas_iter: T.Iterator[types.ImageMetadataOrError]
-            if disable_multiprocessing:
-                image_metadatas_iter = map(
-                    GeotagImagesFromEXIF.geotag_image,
-                    self.image_paths,
-                )
-            else:
-                image_metadatas_iter = pool.imap(
-                    GeotagImagesFromEXIF.geotag_image,
-                    self.image_paths,
-                )
-            return list(
-                tqdm(
-                    image_metadatas_iter,
-                    desc="Extracting geotags from images",
-                    unit="images",
-                    disable=LOG.getEffectiveLevel() <= logging.DEBUG,
-                    total=len(self.image_paths),
-                )
-            )
+class GeotagImagesFromEXIF(GeotagImagesFromGeneric):
+    def _generate_image_extractors(self) -> T.Sequence[ImageEXIFExtractor]:
+        return [ImageEXIFExtractor(path) for path in self.image_paths]

mapillary_tools/geotag/geotag_images_from_exiftool.py

@@ -1,66 +1,91 @@
-import io
+from __future__ import annotations
+
+import contextlib
 import logging
 import typing as T
 import xml.etree.ElementTree as ET
-from multiprocessing import Pool
 from pathlib import Path
 
-from tqdm import tqdm
-
-from .. import exceptions, exiftool_read, types
+from .. import constants, exceptions, exiftool_read, types
+from ..exiftool_runner import ExiftoolRunner
 from .geotag_from_generic import GeotagImagesFromGeneric
-from .geotag_images_from_exif import GeotagImagesFromEXIF, verify_image_exif_write
+from .geotag_images_from_exif import ImageEXIFExtractor
 
 LOG = logging.getLogger(__name__)
 
 
+class ImageExifToolExtractor(ImageEXIFExtractor):
+    def __init__(self, image_path: Path, element: ET.Element):
+        super().__init__(image_path)
+        self.element = element
+
+    @contextlib.contextmanager
+    def _exif_context(self):
+        yield exiftool_read.ExifToolRead(ET.ElementTree(self.element))
+
+
 class GeotagImagesFromExifTool(GeotagImagesFromGeneric):
     def __init__(
         self,
         image_paths: T.Sequence[Path],
         xml_path: Path,
-        num_processes: T.Optional[int] = None,
+        num_processes: int | None = None,
     ):
-        self.image_paths = image_paths
         self.xml_path = xml_path
-        self.num_processes = num_processes
-        super().__init__()
+        super().__init__(image_paths=image_paths, num_processes=num_processes)
 
-    @staticmethod
-    def geotag_image(element: ET.Element) -> types.ImageMetadataOrError:
-        image_path = exiftool_read.find_rdf_description_path(element)
-        assert image_path is not None, "must find the path from the element"
+    def _generate_image_extractors(
+        self,
+    ) -> T.Sequence[ImageExifToolExtractor | types.ErrorMetadata]:
+        rdf_description_by_path = exiftool_read.index_rdf_description_by_path(
+            [self.xml_path]
+        )
 
-        try:
-            exif = exiftool_read.ExifToolRead(ET.ElementTree(element))
-            image_metadata = GeotagImagesFromEXIF.build_image_metadata(
-                image_path, exif, skip_lonlat_error=False
-            )
-            # load the image bytes into memory to avoid reading it multiple times
-            with image_path.open("rb") as fp:
-                image_bytesio = io.BytesIO(fp.read())
-            image_bytesio.seek(0, io.SEEK_SET)
-            verify_image_exif_write(
-                image_metadata,
-                image_bytes=image_bytesio.read(),
-            )
-        except Exception as ex:
-            return types.describe_error_metadata(
-                ex, image_path, filetype=types.FileType.IMAGE
+        results: list[ImageExifToolExtractor | types.ErrorMetadata] = []
+
+        for path in self.image_paths:
+            rdf_description = rdf_description_by_path.get(
+                exiftool_read.canonical_path(path)
             )
+            if rdf_description is None:
+                exc = exceptions.MapillaryEXIFNotFoundError(
+                    f"The {exiftool_read._DESCRIPTION_TAG} XML element for the image not found"
+                )
+                results.append(
+                    types.describe_error_metadata(
+                        exc, path, filetype=types.FileType.IMAGE
+                    )
+                )
+            else:
+                results.append(ImageExifToolExtractor(path, rdf_description))
 
-        image_bytesio.seek(0, io.SEEK_SET)
-        image_metadata.update_md5sum(image_bytesio)
+        return results
 
-        return image_metadata
 
-    def to_description(self) -> T.List[types.ImageMetadataOrError]:
-        rdf_description_by_path = exiftool_read.index_rdf_description_by_path(
-            [self.xml_path]
+class GeotagImagesFromExifToolRunner(GeotagImagesFromGeneric):
+    def _generate_image_extractors(
+        self,
+    ) -> T.Sequence[ImageExifToolExtractor | types.ErrorMetadata]:
+        runner = ExiftoolRunner(constants.EXIFTOOL_PATH)
+
+        LOG.debug(
+            "Extracting XML from %d images with exiftool command: %s",
+            len(self.image_paths),
+            " ".join(runner._build_args_read_stdin()),
         )
+        try:
+            xml = runner.extract_xml(self.image_paths)
+        except FileNotFoundError as ex:
+            raise exceptions.MapillaryExiftoolNotFoundError(ex) from ex
+
+        rdf_description_by_path = (
+            exiftool_read.index_rdf_description_by_path_from_xml_element(
+                ET.fromstring(xml)
+            )
+        )
+
+        results: list[ImageExifToolExtractor | types.ErrorMetadata] = []
 
-        error_metadatas: T.List[types.ErrorMetadata] = []
-        rdf_descriptions: T.List[ET.Element] = []
         for path in self.image_paths:
             rdf_description = rdf_description_by_path.get(
                 exiftool_read.canonical_path(path)
@@ -69,41 +94,12 @@ class GeotagImagesFromExifTool(GeotagImagesFromGeneric):
                 exc = exceptions.MapillaryEXIFNotFoundError(
                     f"The {exiftool_read._DESCRIPTION_TAG} XML element for the image not found"
                 )
-                error_metadatas.append(
+                results.append(
                     types.describe_error_metadata(
                         exc, path, filetype=types.FileType.IMAGE
                     )
                 )
             else:
-                rdf_descriptions.append(rdf_description)
-
-        if self.num_processes is None:
-            num_processes = self.num_processes
-            disable_multiprocessing = False
-        else:
-            num_processes = max(self.num_processes, 1)
-            disable_multiprocessing = self.num_processes <= 0
-
-        with Pool(processes=num_processes) as pool:
-            image_metadatas_iter: T.Iterator[types.ImageMetadataOrError]
-            if disable_multiprocessing:
-                image_metadatas_iter = map(
-                    GeotagImagesFromExifTool.geotag_image,
-                    rdf_descriptions,
-                )
-            else:
-                image_metadatas_iter = pool.imap(
-                    GeotagImagesFromExifTool.geotag_image,
-                    rdf_descriptions,
-                )
-            image_metadata_or_errors = list(
-                tqdm(
-                    image_metadatas_iter,
-                    desc="Extracting geotags from ExifTool XML",
-                    unit="images",
-                    disable=LOG.getEffectiveLevel() <= logging.DEBUG,
-                    total=len(self.image_paths),
-                )
-            )
+                results.append(ImageExifToolExtractor(path, rdf_description))
 
-        return error_metadatas + image_metadata_or_errors
+        return results

mapillary_tools/geotag/geotag_images_from_exiftool_both_image_and_video.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 import typing as T
 from pathlib import Path
@@ -20,28 +22,14 @@ class GeotagImagesFromExifToolBothImageAndVideo(GeotagImagesFromGeneric):
         image_paths: T.Sequence[Path],
         xml_path: Path,
         offset_time: float = 0.0,
-        num_processes: T.Optional[int] = None,
+        num_processes: int | None = None,
     ):
-        self.image_paths = image_paths
+        super().__init__(image_paths, num_processes=num_processes)
         self.xml_path = xml_path
         self.offset_time = offset_time
-        self.num_processes = num_processes
-        super().__init__()
-
-    def to_description(self) -> T.List[types.ImageMetadataOrError]:
-        # will return this list
-        final_image_metadatas: T.List[types.ImageMetadataOrError] = []
 
-        # find the images that can be geotagged from EXIF
-        image_metadatas_from_exiftool = (
-            geotag_images_from_exiftool.GeotagImagesFromExifTool(
-                self.image_paths,
-                self.xml_path,
-                num_processes=self.num_processes,
-            ).to_description()
-        )
-
-        # find all video paths in self.xml_path
+    def geotag_samples(self) -> list[types.ImageMetadataOrError]:
+        # Find all video paths in self.xml_path
         rdf_description_by_path = exiftool_read.index_rdf_description_by_path(
             [self.xml_path]
         )
@@ -49,45 +37,41 @@ class GeotagImagesFromExifToolBothImageAndVideo(GeotagImagesFromGeneric):
             [Path(pathstr) for pathstr in rdf_description_by_path.keys()],
             skip_subfolders=True,
         )
+        # Find all video paths that have sample images
+        samples_by_video = utils.find_all_image_samples(self.image_paths, video_paths)
 
-        # will try to geotag these error metadatas from video later
-        error_metadata_by_image_path = {}
-        for image_metadata in image_metadatas_from_exiftool:
-            if isinstance(image_metadata, types.ErrorMetadata):
-                error_metadata_by_image_path[image_metadata.filename] = image_metadata
-            else:
-                final_image_metadatas.append(image_metadata)
-
-        maybe_image_samples = list(error_metadata_by_image_path.keys())
-
-        # find all video paths that have sample images
-        video_paths_with_image_samples = list(
-            utils.find_all_image_samples(maybe_image_samples, video_paths).keys()
-        )
-
-        video_metadatas = (
+        video_metadata_or_errors = (
             geotag_videos_from_exiftool_video.GeotagVideosFromExifToolVideo(
-                video_paths_with_image_samples,
+                list(samples_by_video.keys()),
                 self.xml_path,
                 num_processes=self.num_processes,
             ).to_description()
         )
-
-        image_metadatas_from_video = geotag_images_from_video.GeotagImagesFromVideo(
-            maybe_image_samples,
-            video_metadatas,
+        sample_paths = sum(samples_by_video.values(), [])
+        sample_metadata_or_errors = geotag_images_from_video.GeotagImagesFromVideo(
+            sample_paths,
+            video_metadata_or_errors,
             offset_time=self.offset_time,
             num_processes=self.num_processes,
         ).to_description()
-        final_image_metadatas.extend(image_metadatas_from_video)
 
-        # add back error metadatas that can not be geotagged at all
-        actual_image_sample_paths = set(
-            image_metadata.filename for image_metadata in image_metadatas_from_video
+        return sample_metadata_or_errors
+
+    def to_description(self) -> list[types.ImageMetadataOrError]:
+        sample_metadata_or_errors = self.geotag_samples()
+
+        sample_paths = set(metadata.filename for metadata in sample_metadata_or_errors)
+
+        non_sample_paths = [
+            path for path in self.image_paths if path not in sample_paths
+        ]
+
+        non_sample_metadata_or_errors = (
+            geotag_images_from_exiftool.GeotagImagesFromExifTool(
+                non_sample_paths,
+                self.xml_path,
+                num_processes=self.num_processes,
+            ).to_description()
         )
-        for path, error_metadata in error_metadata_by_image_path.items():
-            if path not in actual_image_sample_paths:
-                final_image_metadatas.append(error_metadata)
 
-        assert len(final_image_metadatas) <= len(self.image_paths)
-        return final_image_metadatas
+        return sample_metadata_or_errors + non_sample_metadata_or_errors