Remove dead code: unused functions, deprecated options, and unreachable code

- Remove unused extract_camera_model() from gpmf_parser.py and
  blackvue_parser.py (superseded by extract_gopro_info() and
  extract_blackvue_info())
- Remove deprecated --video_sample_interval and --video_duration_ratio
  CLI options (deprecated since v0.10.0), along with the
  _sample_single_video_by_interval() function, xor() helper, and
  related constants
- Remove dead rich logging code path in utils.py (unconditional
  raise ImportError made it unreachable)
- Remove deprecated MAPMetaTags field from types.py, schema, and
  JSON schema (deprecated since v0.10.0, never set in production)
- Remove commented-out ffmpeg options from ffmpeg.py
- Update tests to reflect removed features

Author: caglarpir

mapillary_tools/blackvue_parser.py

@@ -76,17 +76,6 @@ def extract_blackvue_info(fp: T.BinaryIO) -> BlackVueInfo | None:
     return BlackVueInfo(model=model, gps=points)
 
 
-def extract_camera_model(fp: T.BinaryIO) -> str:
-    try:
-        cprt_bytes = sparser.parse_mp4_data_first(fp, [b"free", b"cprt"])
-    except sparser.ParsingError:
-        return ""
-
-    if cprt_bytes is None:
-        return ""
-
-    return _extract_camera_model_from_cprt(cprt_bytes)
-
 
 def _extract_camera_model_from_cprt(cprt_bytes: bytes) -> str:
     """

mapillary_tools/commands/sample_video.py

@@ -25,20 +25,6 @@ def add_basic_arguments(self, parser: argparse.ArgumentParser):
             type=float,
             required=False,
         )
-        group.add_argument(
-            "--video_sample_interval",
-            help="[DEPRECATED since v0.10.0] Time interval, in seconds, for sampling video frames. Since v0.10.0 you must disable distance-sampling with --video_sample_distance=-1 in order to apply this option. [default: %(default)s]",
-            default=constants.VIDEO_SAMPLE_INTERVAL,
-            type=float,
-            required=False,
-        )
-        group.add_argument(
-            "--video_duration_ratio",
-            help="[DEPRECATED since v0.10.0] Real time video duration ratio of the under or oversampled video duration. [default: %(default)s]",
-            type=float,
-            default=constants.VIDEO_DURATION_RATIO,
-            required=False,
-        )
         group.add_argument(
             "--video_start_time",
             help="Video start time specified in YYYY_MM_DD_HH_MM_SS_sss in UTC. For example 2020_12_28_12_36_36_508 represents 2020-12-28T12:36:36.508Z.",

mapillary_tools/constants.py

@@ -87,11 +87,8 @@ def _parse_scaled_integers(
 ############################
 ##### VIDEO PROCESSING #####
 ############################
-# In seconds
-VIDEO_SAMPLE_INTERVAL = float(os.getenv(_ENV_PREFIX + "VIDEO_SAMPLE_INTERVAL", -1))
 # In meters
 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")

mapillary_tools/ffmpeg.py

@@ -279,22 +279,11 @@ def extract_specified_frames(
                         *["-filter_script:v", select_file.name],
                         # Each frame is passed with its timestamp from the demuxer to the muxer
                         *["-vsync", "0"],
-                        # vsync is deprecated by fps_mode,
-                        # but fps_mode is not avaliable on some older versions ;(
-                        # *[f"-fps_mode:{stream_specifier}", "passthrough"],
                         # Set the number of video frames to output (this is an optimization to let ffmpeg stop early)
                         *["-frames:v", str(len(frame_indices))],
-                        # Disabled because it doesn't always name the sample images as expected
-                        # For example "select(n\,1)" we expected the first sample to be IMG_001.JPG
-                        # but it could be IMG_005.JPG
-                        # https://www.ffmpeg.org/ffmpeg-formats.html#Options-21
-                        # If set to 1, expand the filename with pts from pkt->pts. Default value is 0.
-                        # *["-frame_pts", "1"],
                     ],
                     # Video quality level (or the alias -q:v)
-                    # -q:v=1 is the best quality but larger image sizes
                     # see https://stackoverflow.com/a/10234065
-                    # *["-qscale:v", "1", "-qmin", "1"],
                     *["-qscale:v", "2"],
                     # output
                     output_template,

mapillary_tools/gpmf/gpmf_parser.py

@@ -218,21 +218,6 @@ def extract_gopro_info(
     return None
 
 
-def extract_camera_model(fp: T.BinaryIO) -> str:
-    moov = MovieBoxParser.parse_stream(fp)
-    for track in moov.extract_tracks():
-        if _contains_gpmd_description(track):
-            gpmd_samples = _filter_gpmd_samples(track)
-            dvnm_by_dvid: dict[int, bytes] = {}
-            device_found = _load_telemetry_from_samples(
-                fp, gpmd_samples, dvnm_by_dvid=dvnm_by_dvid
-            )
-            if not device_found:
-                return ""
-            return _extract_camera_model_from_devices(dvnm_by_dvid)
-
-    return ""
-
 
 def _gps5_timestamp_to_epoch_time(dtstr: str):
     # yymmddhhmmss.sss

mapillary_tools/sample_video.py

@@ -44,28 +44,21 @@ def _normalize_path(
     return video_dir, video_list
 
 
-def xor(a: bool, b: bool):
-    # xor https://stackoverflow.com/a/433161
-    return bool(a) ^ bool(b)
-
-
 def sample_video(
     video_import_path: Path,
     import_path: Path,
     # None if called from the sample_video command
     skip_subfolders=False,
     video_sample_distance=constants.VIDEO_SAMPLE_DISTANCE,
-    video_sample_interval=constants.VIDEO_SAMPLE_INTERVAL,
-    video_duration_ratio=constants.VIDEO_DURATION_RATIO,
     video_start_time: str | None = None,
     skip_sample_errors: bool = False,
     rerun: bool = False,
 ) -> None:
     video_dir, video_list = _normalize_path(video_import_path, skip_subfolders)
 
-    if not xor(0 <= video_sample_distance, 0 < video_sample_interval):
+    if video_sample_distance < 0:
         raise exceptions.MapillaryBadParameterError(
-            f"Expect either non-negative video_sample_distance or positive video_sample_interval but got {video_sample_distance} and {video_sample_interval} respectively"
+            f"Expect non-negative video_sample_distance but got {video_sample_distance}"
         )
 
     video_start_time_dt: datetime.datetime | None = None
@@ -106,24 +99,12 @@ def sample_video(
             continue
 
         try:
-            if 0 <= video_sample_distance:
-                _sample_single_video_by_distance(
-                    video_path,
-                    sample_dir,
-                    sample_distance=video_sample_distance,
-                    start_time=video_start_time_dt,
-                )
-            else:
-                assert 0 < video_sample_interval, (
-                    "expect positive video_sample_interval but got {video_sample_interval}"
-                )
-                _sample_single_video_by_interval(
-                    video_path,
-                    sample_dir,
-                    sample_interval=video_sample_interval,
-                    duration_ratio=video_duration_ratio,
-                    start_time=video_start_time_dt,
-                )
+            _sample_single_video_by_distance(
+                video_path,
+                sample_dir,
+                sample_distance=video_sample_distance,
+                start_time=video_start_time_dt,
+            )
         except ffmpeglib.FFmpegNotFoundError as ex:
             # fatal error
             raise exceptions.MapillaryFFmpegNotFoundError(str(ex)) from ex
@@ -179,40 +160,6 @@ def wip_sample_dir(sample_dir: Path) -> Path:
     )
 
 
-def _sample_single_video_by_interval(
-    video_path: Path,
-    sample_dir: Path,
-    sample_interval: float,
-    duration_ratio: float,
-    start_time: datetime.datetime | None = None,
-) -> None:
-    ffmpeg = ffmpeglib.FFMPEG(constants.FFMPEG_PATH, constants.FFPROBE_PATH)
-
-    if start_time is None:
-        start_time = ffmpeglib.Probe(
-            ffmpeg.probe_format_and_streams(video_path)
-        ).probe_video_start_time()
-        if start_time is None:
-            raise exceptions.MapillaryVideoError(
-                f"Unable to extract video start time from {video_path}"
-            )
-
-    with wip_dir_context(wip_sample_dir(sample_dir), sample_dir) as wip_dir:
-        ffmpeg.extract_frames_by_interval(video_path, wip_dir, sample_interval)
-        frame_samples = ffmpeglib.FFMPEG.sort_selected_samples(wip_dir, video_path)
-        for frame_idx_1based, sample_paths in frame_samples:
-            assert len(sample_paths) == 1
-            if sample_paths[0] is None:
-                continue
-            # extract_frames() produces 1-based frame indices so we need to subtract 1 here
-            seconds = (frame_idx_1based - 1) * sample_interval * duration_ratio
-            timestamp = start_time + datetime.timedelta(seconds=seconds)
-            exif_edit = ExifEdit(sample_paths[0])
-            exif_edit.add_date_time_original(timestamp)
-            exif_edit.add_gps_datetime(timestamp)
-            exif_edit.write()
-
-
 def _within_track_time_range_buffered(points, t: float) -> bool:
     # apply 1ms buffer, which is MAPCaptureTime's precision
     start_point_time = points[0].time - 0.001

mapillary_tools/serializer/description.py

@@ -147,8 +147,6 @@ class ErrorDescription(TypedDict, total=False):
             "description": "Arbitrary key for grouping images",
             "pattern": "[a-zA-Z0-9_-]+",
         },
-        # deprecated since v0.10.0; keep here for compatibility
-        "MAPMetaTags": {"type": "object"},
         "MAPDeviceMake": {"type": "string"},
         "MAPDeviceModel": {"type": "string"},
         "MAPGPSAccuracyMeters": {"type": "number"},
@@ -439,7 +437,7 @@ def _as_image_desc(cls, metadata: ImageMetadata) -> ImageDescription:
                 value = getattr(metadata, field.name)
                 if value is not None:
                     # ignore error: TypedDict key must be a string literal;
-                    # expected one of ("MAPMetaTags", "MAPDeviceMake", "MAPDeviceModel", "MAPGPSAccuracyMeters", "MAPCameraUUID", ...)
+                    # expected one of ("MAPDeviceMake", "MAPDeviceModel", "MAPGPSAccuracyMeters", "MAPCameraUUID", ...)
                     desc[field.name] = value  # type: ignore
         return desc
 

mapillary_tools/types.py

@@ -50,7 +50,6 @@ class ImageMetadata(geo.Point):
     MAPGPSAccuracyMeters: float | None = None
     MAPCameraUUID: str | None = None
     MAPOrientation: int | None = None
-    MAPMetaTags: dict | None = None
     MAPFilename: str | None = None
 
     def update_md5sum(self, image_data: T.BinaryIO | None = None) -> None:

mapillary_tools/utils.py

@@ -260,20 +260,12 @@ def configure_logger(
 
     logger.setLevel(level)
 
-    try:
-        # Disable globally for now. TODO Disable it in non-interactive mode only
-        raise ImportError
-        from rich.console import Console  # type: ignore[import]
-        from rich.logging import RichHandler  # type: ignore[import]
-    except ImportError:
-        formatter = logging.Formatter(
-            "%(asctime)s.%(msecs)03d - %(levelname)-7s - %(message)s",
-            datefmt="%H:%M:%S",
-        )
-        handler: logging.Handler = logging.StreamHandler()
-        handler.setFormatter(formatter)
-    else:
-        handler = RichHandler(console=Console(stderr=True), rich_tracebacks=True)  # type: ignore
+    formatter = logging.Formatter(
+        "%(asctime)s.%(msecs)03d - %(levelname)-7s - %(message)s",
+        datefmt="%H:%M:%S",
+    )
+    handler: logging.Handler = logging.StreamHandler()
+    handler.setFormatter(formatter)
 
     logger.addHandler(handler)
 

schema/image_description_schema.json

@@ -139,9 +139,6 @@
                     "description": "Arbitrary key for grouping images",
                     "pattern": "[a-zA-Z0-9_-]+"
                 },
-                "MAPMetaTags": {
-                    "type": "object"
-                },
                 "MAPDeviceMake": {
                     "type": "string"
                 },