mapillary-tools 0.10.6a1__py3-none-any.whl → 0.11.0b2__py3-none-any.whl

mapillary_tools/__init__.py

@@ -1 +1 @@
-VERSION = "0.10.6a1"
+VERSION = "0.11.0b2"

mapillary_tools/api_v4.py

@@ -1,15 +1,8 @@
 import os
-import sys
 import typing as T
-from typing import Union
 
 import requests
 
-if sys.version_info >= (3, 8):
-    from typing import Literal  # pylint: disable=no-name-in-module
-else:
-    from typing_extensions import Literal
-
 MAPILLARY_CLIENT_TOKEN = os.getenv(
     "MAPILLARY_CLIENT_TOKEN", "MLY|5675152195860640|6b02c72e6e3c801e5603ab0495623282"
 )
@@ -31,7 +24,7 @@ def get_upload_token(email: str, password: str) -> requests.Response:
 
 
 def fetch_organization(
-    user_access_token: str, organization_id: Union[int, str]
+    user_access_token: str, organization_id: T.Union[int, str]
 ) -> requests.Response:
     resp = requests.get(
         f"{MAPILLARY_GRAPH_API_ENDPOINT}/{organization_id}",
@@ -47,7 +40,7 @@ def fetch_organization(
     return resp
 
 
-ActionType = Literal[
+ActionType = T.Literal[
     "upload_started_upload", "upload_finished_upload", "upload_failed_upload"
 ]
 

mapillary_tools/commands/__main__.py

@@ -63,14 +63,14 @@ def add_general_arguments(parser, command):
     elif command in ["upload"]:
         parser.add_argument(
             "import_path",
-            help="Path to your images.",
+            help="Paths to your images or videos.",
             nargs="+",
             type=Path,
         )
     elif command in ["process", "process_and_upload"]:
         parser.add_argument(
             "import_path",
-            help="Path to your images.",
+            help="Paths to your images or videos.",
             nargs="+",
             type=Path,
         )
@@ -167,7 +167,9 @@ def main():
     try:
         args.func(argvars)
     except exceptions.MapillaryUserError as exc:
-        LOG.error("%s: %s", exc.__class__.__name__, exc)
+        LOG.error(
+            "%s: %s", exc.__class__.__name__, exc, exc_info=log_level == logging.DEBUG
+        )
         sys.exit(exc.exit_code)
 
 

mapillary_tools/commands/process.py

@@ -171,6 +171,13 @@ class Command:
             required=False,
             type=Path,
         )
+        group_geotagging.add_argument(
+            "--video_geotag_source",
+            help="Name of the video data extractor and optional arguments. Can be specified multiple times. See the documentation for details. [Experimental, subject to change]",
+            action="append",
+            default=[],
+            required=False,
+        )
         group_geotagging.add_argument(
             "--interpolation_use_gpx_start_time",
             help=f"If supplied, the first image will use the first GPX point time for interpolation, which means the image location will be interpolated to the first GPX point too. Only works for geotagging from {', '.join(geotag_gpx_based_sources)}.",
@@ -261,13 +268,14 @@ class Command:
             vars_args["duplicate_angle"] = 360
 
         metadatas = process_geotag_properties(
+            vars_args=vars_args,
             **(
                 {
                     k: v
                     for k, v in vars_args.items()
                     if k in inspect.getfullargspec(process_geotag_properties).args
                 }
-            )
+            ),
         )
 
         metadatas = process_import_meta_properties(

mapillary_tools/constants.py

@@ -18,6 +18,7 @@ VIDEO_SAMPLE_DISTANCE = float(os.getenv(_ENV_PREFIX + "VIDEO_SAMPLE_DISTANCE", 3
 VIDEO_DURATION_RATIO = float(os.getenv(_ENV_PREFIX + "VIDEO_DURATION_RATIO", 1))
 FFPROBE_PATH: str = os.getenv(_ENV_PREFIX + "FFPROBE_PATH", "ffprobe")
 FFMPEG_PATH: str = os.getenv(_ENV_PREFIX + "FFMPEG_PATH", "ffmpeg")
+EXIFTOOL_PATH: str = os.getenv(_ENV_PREFIX + "EXIFTOOL_PATH", "exiftool")
 IMAGE_DESCRIPTION_FILENAME = os.getenv(
     _ENV_PREFIX + "IMAGE_DESCRIPTION_FILENAME", "mapillary_image_description.json"
 )

mapillary_tools/exceptions.py

@@ -34,6 +34,10 @@ class MapillaryFFmpegNotFoundError(MapillaryUserError):
     help = "https://github.com/mapillary/mapillary_tools#video-support"
 
 
+class MapillaryExiftoolNotFoundError(MapillaryUserError):
+    exit_code = 8
+
+
 class MapillaryDescriptionError(Exception):
     pass
 

mapillary_tools/exif_read.py

@@ -1,8 +1,10 @@
 import abc
 import datetime
 import logging
+import re
 import typing as T
 import xml.etree.ElementTree as et
+from fractions import Fraction
 from pathlib import Path
 
 import exifread
@@ -21,6 +23,8 @@ XMP_NAMESPACES = {
 # https://github.com/ianare/exif-py/issues/167
 EXIFREAD_LOG = logging.getLogger("exifread")
 EXIFREAD_LOG.setLevel(logging.ERROR)
+SIGN_BY_DIRECTION = {None: 1, "N": 1, "S": -1, "E": 1, "W": -1}
+ADOBE_FORMAT_REGEX = re.compile(r"(\d+),(\d{1,3}\.?\d*)([NSWE])")
 
 
 def eval_frac(value: Ratio) -> float:
@@ -47,6 +51,38 @@ def gps_to_decimal(values: T.Tuple[Ratio, Ratio, Ratio]) -> T.Optional[float]:
     return degrees + minutes / 60 + seconds / 3600
 
 
+def _parse_coord_numeric(coord: str, ref: T.Optional[str]) -> T.Optional[float]:
+    try:
+        return float(coord) * SIGN_BY_DIRECTION[ref]
+    except (ValueError, KeyError):
+        return None
+
+
+def _parse_coord_adobe(coord: str) -> T.Optional[float]:
+    """
+    Parse Adobe coordinate format: <degrees,fractionalminutes[NSEW]>
+    """
+    matches = ADOBE_FORMAT_REGEX.match(coord)
+    if matches:
+        deg = Ratio(int(matches.group(1)), 1)
+        min_frac = Fraction.from_float(float(matches.group(2)))
+        min = Ratio(min_frac.numerator, min_frac.denominator)
+        sec = Ratio(0, 1)
+        converted = gps_to_decimal((deg, min, sec))
+        if converted is not None:
+            return converted * SIGN_BY_DIRECTION[matches.group(3)]
+    return None
+
+
+def _parse_coord(coord: T.Optional[str], ref: T.Optional[str]) -> T.Optional[float]:
+    if coord is None:
+        return None
+    parsed = _parse_coord_numeric(coord, ref)
+    if parsed is None:
+        parsed = _parse_coord_adobe(coord)
+    return parsed
+
+
 def _parse_iso(dtstr: str) -> T.Optional[datetime.datetime]:
     try:
         return datetime.datetime.fromisoformat(dtstr)
@@ -378,22 +414,22 @@ class ExifReadFromXMP(ExifReadABC):
         )
 
     def extract_lon_lat(self) -> T.Optional[T.Tuple[float, float]]:
-        lat = self._extract_alternative_fields(["exif:GPSLatitude"], float)
+        lat_ref = self._extract_alternative_fields(["exif:GPSLatitudeRef"], str)
+        lat_str: T.Optional[str] = self._extract_alternative_fields(
+            ["exif:GPSLatitude"], str
+        )
+        lat: T.Optional[float] = _parse_coord(lat_str, lat_ref)
         if lat is None:
             return None
 
-        lon = self._extract_alternative_fields(["exif:GPSLongitude"], float)
+        lon_ref = self._extract_alternative_fields(["exif:GPSLongitudeRef"], str)
+        lon_str: T.Optional[str] = self._extract_alternative_fields(
+            ["exif:GPSLongitude"], str
+        )
+        lon = _parse_coord(lon_str, lon_ref)
         if lon is None:
             return None
 
-        ref = self._extract_alternative_fields(["exif:GPSLongitudeRef"], str)
-        if ref and ref.upper() == "W":
-            lon = -1 * lon
-
-        ref = self._extract_alternative_fields(["exif:GPSLatitudeRef"], str)
-        if ref and ref.upper() == "S":
-            lat = -1 * lat
-
         return lon, lat
 
     def extract_make(self) -> T.Optional[str]:

mapillary_tools/exiftool_read.py

@@ -310,6 +310,10 @@ class ExifToolRead(exif_read.ExifReadABC):
         if lon_lat is not None:
             return lon_lat
 
+        lon_lat = self._extract_lon_lat("XMP-exif:GPSLongitude", "XMP-exif:GPSLatitude")
+        if lon_lat is not None:
+            return lon_lat
+
         return None
 
     def _extract_lon_lat(

mapillary_tools/ffmpeg.py

@@ -11,22 +11,17 @@ import tempfile
 import typing as T
 from pathlib import Path
 
-if sys.version_info >= (3, 8):
-    from typing import TypedDict  # pylint: disable=no-name-in-module
-else:
-    from typing_extensions import TypedDict
-
 LOG = logging.getLogger(__name__)
 FRAME_EXT = ".jpg"
 NA_STREAM_IDX = "NA"
 
 
-class StreamTag(TypedDict):
+class StreamTag(T.TypedDict):
     creation_time: str
     language: str
 
 
-class Stream(TypedDict):
+class Stream(T.TypedDict):
     codec_name: str
     codec_tag_string: str
     codec_type: str
@@ -37,7 +32,7 @@ class Stream(TypedDict):
     width: int
 
 
-class ProbeOutput(TypedDict):
+class ProbeOutput(T.TypedDict):
     streams: T.List[Stream]
 
 

mapillary_tools/geotag/construct_mp4_parser.py

@@ -1,17 +1,11 @@
 # pyre-ignore-all-errors[5, 16, 21, 58]
 
-import sys
 import typing as T
 
-if sys.version_info >= (3, 8):
-    from typing import Literal, TypedDict  # pylint: disable=no-name-in-module
-else:
-    from typing_extensions import Literal, TypedDict
-
 import construct as C
 
 
-BoxType = Literal[
+BoxType = T.Literal[
     b"@mak",
     b"@mod",
     b"co64",
@@ -46,7 +40,7 @@ BoxType = Literal[
 ]
 
 
-class BoxDict(TypedDict, total=True):
+class BoxDict(T.TypedDict, total=True):
     type: BoxType
     data: T.Union[T.Sequence["BoxDict"], T.Dict[str, T.Any], bytes]
 

mapillary_tools/geotag/gpmf_parser.py

@@ -1,13 +1,7 @@
 import io
 import pathlib
-import sys
 import typing as T
 
-if sys.version_info >= (3, 8):
-    from typing import TypedDict  # pylint: disable=no-name-in-module
-else:
-    from typing_extensions import TypedDict
-
 import construct as C
 
 from .. import geo
@@ -35,7 +29,7 @@ NOTE:
 """
 
 
-class KLVDict(TypedDict):
+class KLVDict(T.TypedDict):
     key: bytes
     type: bytes
     structure_size: int

mapillary_tools/process_geotag_properties.py

@@ -3,16 +3,10 @@ import datetime
 import itertools
 import json
 import logging
-import sys
 import typing as T
 from multiprocessing import Pool
 from pathlib import Path
 
-if sys.version_info >= (3, 8):
-    from typing import Literal  # pylint: disable=no-name-in-module
-else:
-    from typing_extensions import Literal
-
 from tqdm import tqdm
 
 from . import constants, exceptions, exif_write, history, types, utils
@@ -26,16 +20,30 @@ from .geotag import (
     geotag_videos_from_exiftool_video,
     geotag_videos_from_video,
 )
-from .types import FileType
+from .types import FileType, VideoMetadataOrError
+
+from .video_data_extraction.cli_options import CliOptions, CliParserOptions
+from .video_data_extraction.extract_video_data import VideoDataExtractor
 
 
 LOG = logging.getLogger(__name__)
 
 
-GeotagSource = Literal[
+GeotagSource = T.Literal[
     "gopro_videos", "blackvue_videos", "camm", "exif", "gpx", "nmea", "exiftool"
 ]
 
+VideoGeotagSource = T.Literal[
+    "video",
+    "camm",
+    "gopro",
+    "blackvue",
+    "gpx",
+    "nmea",
+    "exiftool_xml",
+    "exiftool_runtime",
+]
+
 
 def _process_images(
     image_paths: T.Sequence[Path],
@@ -46,7 +54,7 @@ def _process_images(
     interpolation_offset_time: float = 0.0,
     num_processes: T.Optional[int] = None,
     skip_subfolders=False,
-) -> T.List[types.ImageMetadataOrError]:
+) -> T.Sequence[types.ImageMetadataOrError]:
     geotag: geotag_from_generic.GeotagImagesFromGeneric
 
     if video_import_path is not None:
@@ -130,6 +138,37 @@ def _process_images(
     return geotag.to_description()
 
 
+def _process_videos(
+    geotag_source: str,
+    geotag_source_path: T.Optional[Path],
+    video_paths: T.Sequence[Path],
+    num_processes: T.Optional[int],
+    filetypes: T.Optional[T.Set[FileType]],
+) -> T.Sequence[VideoMetadataOrError]:
+    geotag: geotag_from_generic.GeotagVideosFromGeneric
+    if geotag_source == "exiftool":
+        if geotag_source_path is None:
+            raise exceptions.MapillaryFileNotFoundError(
+                "Geotag source path (--geotag_source_path) is required"
+            )
+        if not geotag_source_path.exists():
+            raise exceptions.MapillaryFileNotFoundError(
+                f"Geotag source file not found: {geotag_source_path}"
+            )
+        geotag = geotag_videos_from_exiftool_video.GeotagVideosFromExifToolVideo(
+            video_paths,
+            geotag_source_path,
+            num_processes=num_processes,
+        )
+    else:
+        geotag = geotag_videos_from_video.GeotagVideosFromVideo(
+            video_paths,
+            filetypes=filetypes,
+            num_processes=num_processes,
+        )
+    return geotag.to_description()
+
+
 def _normalize_import_paths(
     import_path: T.Union[Path, T.Sequence[Path]]
 ) -> T.Sequence[Path]:
@@ -143,6 +182,7 @@ def _normalize_import_paths(
 
 
 def process_geotag_properties(
+    vars_args: T.Dict,  # Hello, I'm a hack
     import_path: T.Union[Path, T.Sequence[Path]],
     filetypes: T.Set[FileType],
     geotag_source: GeotagSource,
@@ -176,51 +216,43 @@ def process_geotag_properties(
             skip_subfolders=skip_subfolders,
             check_file_suffix=check_file_suffix,
         )
-        image_metadatas = _process_images(
-            image_paths,
-            geotag_source=geotag_source,
-            geotag_source_path=geotag_source_path,
-            video_import_path=video_import_path,
-            interpolation_use_gpx_start_time=interpolation_use_gpx_start_time,
-            interpolation_offset_time=interpolation_offset_time,
-            num_processes=num_processes,
-            skip_subfolders=skip_subfolders,
-        )
-        metadatas.extend(image_metadatas)
-
-    if (
-        FileType.CAMM in filetypes
-        or FileType.GOPRO in filetypes
-        or FileType.BLACKVUE in filetypes
-        or FileType.VIDEO in filetypes
-    ):
-        video_paths = utils.find_videos(
-            import_paths,
-            skip_subfolders=skip_subfolders,
-            check_file_suffix=check_file_suffix,
-        )
-        geotag: geotag_from_generic.GeotagVideosFromGeneric
-        if geotag_source == "exiftool":
-            if geotag_source_path is None:
-                raise exceptions.MapillaryFileNotFoundError(
-                    "Geotag source path (--geotag_source_path) is required"
-                )
-            if not geotag_source_path.exists():
-                raise exceptions.MapillaryFileNotFoundError(
-                    f"Geotag source file not found: {geotag_source_path}"
-                )
-            geotag = geotag_videos_from_exiftool_video.GeotagVideosFromExifToolVideo(
-                video_paths,
-                geotag_source_path,
+        if image_paths:
+            image_metadatas = _process_images(
+                image_paths,
+                geotag_source=geotag_source,
+                geotag_source_path=geotag_source_path,
+                video_import_path=video_import_path,
+                interpolation_use_gpx_start_time=interpolation_use_gpx_start_time,
+                interpolation_offset_time=interpolation_offset_time,
                 num_processes=num_processes,
+                skip_subfolders=skip_subfolders,
             )
-        else:
-            geotag = geotag_videos_from_video.GeotagVideosFromVideo(
-                video_paths,
-                filetypes=filetypes,
-                num_processes=num_processes,
+            metadatas.extend(image_metadatas)
+
+    # --video_geotag_source is still experimental, for videos execute it XOR the legacy code
+    if vars_args["video_geotag_source"]:
+        metadatas.extend(_process_videos_beta(vars_args))
+    else:
+        if (
+            FileType.CAMM in filetypes
+            or FileType.GOPRO in filetypes
+            or FileType.BLACKVUE in filetypes
+            or FileType.VIDEO in filetypes
+        ):
+            video_paths = utils.find_videos(
+                import_paths,
+                skip_subfolders=skip_subfolders,
+                check_file_suffix=check_file_suffix,
             )
-        metadatas.extend(geotag.to_description())
+            if video_paths:
+                video_metadata = _process_videos(
+                    geotag_source,
+                    geotag_source_path,
+                    video_paths,
+                    num_processes,
+                    filetypes,
+                )
+                metadatas.extend(video_metadata)
 
     # filenames should be deduplicated in utils.find_images/utils.find_videos
     assert len(metadatas) == len(
@@ -230,6 +262,38 @@ def process_geotag_properties(
     return metadatas
 
 
+def _process_videos_beta(vars_args: T.Dict):
+    geotag_sources = vars_args["video_geotag_source"]
+    geotag_sources_opts: T.List[CliParserOptions] = []
+    for source in geotag_sources:
+        parsed_opts: CliParserOptions = {}
+        try:
+            parsed_opts = json.loads(source)
+        except ValueError:
+            if source not in T.get_args(VideoGeotagSource):
+                raise exceptions.MapillaryBadParameterError(
+                    "Unknown beta source %s or invalid JSON", source
+                )
+            parsed_opts = {"source": source}
+
+        if "source" not in parsed_opts:
+            raise exceptions.MapillaryBadParameterError("Missing beta source name")
+
+        geotag_sources_opts.append(parsed_opts)
+
+    options: CliOptions = {
+        "paths": vars_args["import_path"],
+        "recursive": vars_args["skip_subfolders"] == 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"],
+    }
+    extractor = VideoDataExtractor(options)
+    return extractor.process()
+
+
 def _apply_offsets(
     metadatas: T.Iterable[types.ImageMetadata],
     offset_time: float = 0.0,

mapillary_tools/process_sequence_properties.py

@@ -284,6 +284,9 @@ def process_sequence_properties(
         for cur, nxt in geo.pairwise(sequence):
             assert cur.time <= nxt.time, "sequence must be sorted"
 
+    for s in sequences_by_folder:
+        _interpolate_subsecs_for_sorting(s)
+
     # cut sequences
     sequences_after_cut: T.List[PointSequence] = []
     for sequence in sequences_by_folder:
@@ -320,9 +323,6 @@ def process_sequence_properties(
             max_sequence_pixels,
         )
 
-        for c in cut:
-            _interpolate_subsecs_for_sorting(c)
-
         # assign sequence UUIDs
         for c in cut:
             for p in c:

mapillary_tools/types.py

@@ -4,15 +4,10 @@ import enum
 import hashlib
 import json
 import os
-import sys
 import typing as T
 import uuid
 from pathlib import Path
-
-if sys.version_info >= (3, 8):
-    from typing import Literal, TypedDict  # pylint: disable=no-name-in-module
-else:
-    from typing_extensions import Literal, TypedDict
+from typing import Literal, TypedDict
 
 import jsonschema
 

mapillary_tools/uploader.py

@@ -2,7 +2,6 @@ import io
 import json
 import logging
 import os
-import sys
 import tempfile
 import time
 import typing as T
@@ -12,21 +11,15 @@ from contextlib import contextmanager
 from pathlib import Path
 
 import jsonschema
-
 import requests
 
-if sys.version_info >= (3, 8):
-    from typing import Literal  # pylint: disable=no-name-in-module
-else:
-    from typing_extensions import Literal
-
 from . import constants, exif_write, types, upload_api_v4, utils
 
 
 LOG = logging.getLogger(__name__)
 
 
-class Progress(types.TypedDict, total=False):
+class Progress(T.TypedDict, total=False):
     # The size of the chunk, in bytes, that has been uploaded in the last request
     chunk_size: int
 
@@ -68,7 +61,7 @@ class UploadCancelled(Exception):
     pass
 
 
-EventName = Literal[
+EventName = T.Literal[
     "upload_start",
     "upload_fetch_offset",
     "upload_progress",

mapillary_tools/video_data_extraction/cli_options.py

@@ -0,0 +1,22 @@
+import typing as T
+from pathlib import Path
+
+
+known_parser_options = ["source", "pattern", "exiftool_path"]
+
+
+class CliParserOptions(T.TypedDict, total=False):
+    source: str
+    pattern: T.Optional[str]
+    exiftool_path: T.Optional[Path]
+
+
+class CliOptions(T.TypedDict, total=False):
+    paths: T.Sequence[Path]
+    recursive: bool
+    geotag_sources_options: T.Sequence[CliParserOptions]
+    geotag_source_path: Path
+    exiftool_path: Path
+    num_processes: int
+    device_make: T.Optional[str]
+    device_model: T.Optional[str]