mapillary-tools 0.12.1__py3-none-any.whl → 0.13.1__py3-none-any.whl

mapillary_tools/sample_video.py

@@ -9,7 +9,8 @@ from pathlib import Path
 
 from . import constants, exceptions, ffmpeg as ffmpeglib, geo, types, utils
 from .exif_write import ExifEdit
-from .geotag import geotag_videos_from_video, mp4_sample_parser
+from .geotag import geotag_videos_from_video
+from .mp4 import mp4_sample_parser
 from .process_geotag_properties import GeotagSource
 
 LOG = logging.getLogger(__name__)
@@ -117,9 +118,9 @@ def sample_video(
                     start_time=video_start_time_dt,
                 )
             else:
-                assert (
-                    0 < video_sample_interval
-                ), "expect positive video_sample_interval but got {video_sample_interval}"
+                assert 0 < video_sample_interval, (
+                    "expect positive video_sample_interval but got {video_sample_interval}"
+                )
                 _sample_single_video_by_interval(
                     video_path,
                     sample_dir,
@@ -166,7 +167,7 @@ def wip_dir_context(wip_dir: Path, done_dir: Path, rename_timeout_sec: int = 10)
                 except Exception as e:
                     time.sleep(1)
                     error = e
-            if not renamed and not error is None:
+            if not renamed and error is not None:
                 raise error
         else:
             wip_dir.rename(done_dir)
@@ -234,10 +235,10 @@ def _sample_video_stream_by_distance(
     """
 
     LOG.info("Extracting video samples")
-    sorted_samples = list(video_track_parser.parse_samples())
+    sorted_samples = list(video_track_parser.extract_samples())
     # we need sort sampels by composition time (CT) not the decoding offset (DT)
     # CT is the oder of videos streaming to audiences, as well as the order ffmpeg sampling
-    sorted_samples.sort(key=lambda sample: sample.composition_time_offset)
+    sorted_samples.sort(key=lambda sample: sample.exact_composition_time)
     LOG.info("Found total %d video samples", len(sorted_samples))
 
     # interpolate sample points between the GPS track range (with 1ms buffer)
@@ -251,11 +252,11 @@ def _sample_video_stream_by_distance(
         (
             frame_idx_0based,
             video_sample,
-            interpolator.interpolate(video_sample.composition_time_offset),
+            interpolator.interpolate(video_sample.exact_composition_time),
         )
         for frame_idx_0based, video_sample in enumerate(sorted_samples)
         if _within_track_time_range_buffered(
-            points, video_sample.composition_time_offset
+            points, video_sample.exact_composition_time
         )
     ]
     LOG.info("Found total %d interpolated video samples", len(interp_sample_points))
@@ -316,7 +317,7 @@ def _sample_single_video_by_distance(
     LOG.info("Extracting video samples")
     video_stream_idx = video_stream["index"]
     moov_parser = mp4_sample_parser.MovieBoxParser.parse_file(video_path)
-    video_track_parser = moov_parser.parse_track_at(video_stream_idx)
+    video_track_parser = moov_parser.extract_track_at(video_stream_idx)
     sample_points_by_frame_idx = _sample_video_stream_by_distance(
         video_metadata.points, video_track_parser, sample_distance
     )
@@ -338,9 +339,9 @@ def _sample_single_video_by_distance(
                 f"Expect {len(sorted_sample_indices)} samples but extracted {len(frame_samples)} samples"
             )
         for idx, (frame_idx_1based, sample_paths) in enumerate(frame_samples):
-            assert (
-                len(sample_paths) == 1
-            ), "Expect 1 sample path at {frame_idx_1based} but got {sample_paths}"
+            assert len(sample_paths) == 1, (
+                "Expect 1 sample path at {frame_idx_1based} but got {sample_paths}"
+            )
             if idx + 1 != frame_idx_1based:
                 raise exceptions.MapillaryVideoError(
                     f"Expect {sample_paths[0]} to be {idx + 1}th sample but got {frame_idx_1based}"
@@ -351,9 +352,9 @@ def _sample_single_video_by_distance(
                 continue
 
             video_sample, interp = sample_points_by_frame_idx[sample_idx]
-            assert (
-                interp.time == video_sample.composition_time_offset
-            ), f"interpolated time {interp.time} should match the video sample time {video_sample.composition_time_offset}"
+            assert interp.time == video_sample.exact_composition_time, (
+                f"interpolated time {interp.time} should match the video sample time {video_sample.exact_composition_time}"
+            )
 
             timestamp = start_time + datetime.timedelta(seconds=interp.time)
             exif_edit = ExifEdit(sample_paths[0])

mapillary_tools/telemetry.py

@@ -0,0 +1,71 @@
+import dataclasses
+import typing as T
+from enum import Enum, unique
+
+from .geo import Point
+
+
+@unique
+class GPSFix(Enum):
+    NO_FIX = 0
+    FIX_2D = 2
+    FIX_3D = 3
+
+
+@dataclasses.dataclass(order=True)
+class TelemetryMeasurement:
+    """Base class for all telemetry measurements.
+
+    All telemetry measurements must have a timestamp in seconds.
+    This is an abstract base class - do not instantiate directly.
+    Instead use the concrete subclasses: AccelerationData, GyroscopeData, etc.
+    """
+
+    time: float
+
+
+@dataclasses.dataclass
+class GPSPoint(TelemetryMeasurement, Point):
+    epoch_time: T.Optional[float]
+    fix: T.Optional[GPSFix]
+    precision: T.Optional[float]
+    ground_speed: T.Optional[float]
+
+
+@dataclasses.dataclass
+class CAMMGPSPoint(TelemetryMeasurement, Point):
+    time_gps_epoch: float
+    gps_fix_type: int
+    horizontal_accuracy: float
+    vertical_accuracy: float
+    velocity_east: float
+    velocity_north: float
+    velocity_up: float
+    speed_accuracy: float
+
+
+@dataclasses.dataclass(order=True)
+class GyroscopeData(TelemetryMeasurement):
+    """Gyroscope signal in radians/seconds around XYZ axes of the camera."""
+
+    x: float
+    y: float
+    z: float
+
+
+@dataclasses.dataclass(order=True)
+class AccelerationData(TelemetryMeasurement):
+    """Accelerometer reading in meters/second^2 along XYZ axes of the camera."""
+
+    x: float
+    y: float
+    z: float
+
+
+@dataclasses.dataclass(order=True)
+class MagnetometerData(TelemetryMeasurement):
+    """Ambient magnetic field."""
+
+    x: float
+    y: float
+    z: float

mapillary_tools/types.py

@@ -36,6 +36,7 @@ class FileType(enum.Enum):
     GOPRO = "gopro"
     IMAGE = "image"
     VIDEO = "video"
+    ZIP = "zip"
 
 
 @dataclasses.dataclass
@@ -56,6 +57,7 @@ class ImageMetadata(geo.Point):
     MAPMetaTags: T.Optional[T.Dict] = None
     # deprecated since v0.10.0; keep here for compatibility
     MAPFilename: T.Optional[str] = None
+    filesize: T.Optional[int] = None
 
     def update_md5sum(self, image_data: T.Optional[T.BinaryIO] = None) -> None:
         if self.md5sum is None:
@@ -81,6 +83,7 @@ class VideoMetadata:
     points: T.Sequence[geo.Point]
     make: T.Optional[str] = None
     model: T.Optional[str] = None
+    filesize: T.Optional[int] = None
 
     def update_md5sum(self) -> None:
         if self.md5sum is None:
@@ -143,6 +146,7 @@ class ImageDescription(_SequenceOnly, _Image, MetaProperties, total=True):
     # if None or absent, it will be calculated
     md5sum: T.Optional[str]
     filetype: Literal["image"]
+    filesize: T.Optional[int]
 
 
 class _VideoDescriptionRequired(TypedDict, total=True):
@@ -156,6 +160,7 @@ class _VideoDescriptionRequired(TypedDict, total=True):
 class VideoDescription(_VideoDescriptionRequired, total=False):
     MAPDeviceMake: str
     MAPDeviceModel: str
+    filesize: T.Optional[int]
 
 
 class _ErrorDescription(TypedDict, total=False):
@@ -368,6 +373,10 @@ ImageDescriptionFileSchema = merge_schema(
                 "type": ["string", "null"],
                 "description": "MD5 checksum of the image content. If not provided, the uploader will compute it",
             },
+            "filesize": {
+                "type": ["number", "null"],
+                "description": "File size",
+            },
             "filetype": {
                 "type": "string",
                 "enum": [FileType.IMAGE.value],
@@ -394,6 +403,10 @@ VideoDescriptionFileSchema = merge_schema(
                 "type": ["string", "null"],
                 "description": "MD5 checksum of the video content. If not provided, the uploader will compute it",
             },
+            "filesize": {
+                "type": ["number", "null"],
+                "description": "File size",
+            },
             "filetype": {
                 "type": "string",
                 "enum": [
@@ -484,6 +497,7 @@ def _as_video_desc(metadata: VideoMetadata) -> VideoDescription:
         "filename": str(metadata.filename.resolve()),
         "md5sum": metadata.md5sum,
         "filetype": metadata.filetype.value,
+        "filesize": metadata.filesize,
         "MAPGPSTrack": [_encode_point(p) for p in metadata.points],
     }
     if metadata.make:
@@ -497,6 +511,7 @@ def _as_image_desc(metadata: ImageMetadata) -> ImageDescription:
     desc: ImageDescription = {
         "filename": str(metadata.filename.resolve()),
         "md5sum": metadata.md5sum,
+        "filesize": metadata.filesize,
         "filetype": FileType.IMAGE.value,
         "MAPLatitude": round(metadata.lat, _COORDINATES_PRECISION),
         "MAPLongitude": round(metadata.lon, _COORDINATES_PRECISION),
@@ -542,6 +557,7 @@ def _from_image_desc(desc) -> ImageMetadata:
         if k not in [
             "filename",
             "md5sum",
+            "filesize",
             "filetype",
             "MAPLatitude",
             "MAPLongitude",
@@ -554,6 +570,7 @@ def _from_image_desc(desc) -> ImageMetadata:
     return ImageMetadata(
         filename=Path(desc["filename"]),
         md5sum=desc.get("md5sum"),
+        filesize=desc.get("filesize"),
         lat=desc["MAPLatitude"],
         lon=desc["MAPLongitude"],
         alt=desc.get("MAPAltitude"),
@@ -585,6 +602,7 @@ def _from_video_desc(desc: VideoDescription) -> VideoMetadata:
     return VideoMetadata(
         filename=Path(desc["filename"]),
         md5sum=desc["md5sum"],
+        filesize=desc["filesize"],
         filetype=FileType(desc["filetype"]),
         points=[_decode_point(entry) for entry in desc["MAPGPSTrack"]],
         make=desc.get("MAPDeviceMake"),

mapillary_tools/upload.py

@@ -1,4 +1,3 @@
-import enum
 import json
 import logging
 import os
@@ -17,7 +16,6 @@ from . import (
     config,
     constants,
     exceptions,
-    geo,
     history,
     ipc,
     types,
@@ -26,13 +24,9 @@ from . import (
     utils,
     VERSION,
 )
-from .geotag import (
-    blackvue_parser,
-    camm_builder,
-    camm_parser,
-    simple_mp4_builder,
-    utils as video_utils,
-)
+from .camm import camm_builder, camm_parser
+from .geotag import gpmf_parser
+from .mp4 import simple_mp4_builder
 from .types import FileType
 
 JSONDict = T.Dict[str, T.Union[str, int, float, None]]
@@ -42,6 +36,7 @@ MAPILLARY_DISABLE_API_LOGGING = os.getenv("MAPILLARY_DISABLE_API_LOGGING")
 MAPILLARY__ENABLE_UPLOAD_HISTORY_FOR_DRY_RUN = os.getenv(
     "MAPILLARY__ENABLE_UPLOAD_HISTORY_FOR_DRY_RUN"
 )
+MAPILLARY__EXPERIMENTAL_ENABLE_IMU = os.getenv("MAPILLARY__EXPERIMENTAL_ENABLE_IMU")
 CAMM_CONVERTABLES = {FileType.CAMM, FileType.BLACKVUE, FileType.GOPRO}
 
 
@@ -55,12 +50,6 @@ class UploadHTTPError(Exception):
     pass
 
 
-class DirectUploadFileType(enum.Enum):
-    RAW_BLACKVUE = "raw_blackvue"
-    RAW_CAMM = "raw_camm"
-    ZIP = "zip"
-
-
 def wrap_http_exception(ex: requests.HTTPError):
     req = ex.request
     resp = ex.response
@@ -440,7 +429,7 @@ def _api_logging_finished(summary: T.Dict):
     action: api_v4.ActionType = "upload_finished_upload"
     LOG.debug("API Logging for action %s: %s", action, summary)
     try:
-        api_v4.logging(
+        api_v4.log_event(
             action,
             summary,
         )
@@ -462,7 +451,7 @@ def _api_logging_failed(payload: T.Dict, exc: Exception):
     action: api_v4.ActionType = "upload_failed_upload"
     LOG.debug("API Logging for action %s: %s", action, payload)
     try:
-        api_v4.logging(
+        api_v4.log_event(
             action,
             payload_with_reason,
         )
@@ -521,7 +510,6 @@ def _find_metadata_with_filename_existed_in(
 
 def upload(
     import_path: T.Union[Path, T.Sequence[Path]],
-    filetypes: T.Set[T.Union[FileType, DirectUploadFileType]],
     desc_path: T.Optional[str] = None,
     _metadatas_from_process: T.Optional[T.Sequence[types.MetadataOrError]] = None,
     user_name: T.Optional[str] = None,
@@ -529,19 +517,6 @@ def upload(
     dry_run=False,
     skip_subfolders=False,
 ) -> None:
-    if (
-        DirectUploadFileType.RAW_BLACKVUE in filetypes
-        and FileType.BLACKVUE in filetypes
-    ):
-        raise exceptions.MapillaryBadParameterError(
-            f"filetypes should contain either {DirectUploadFileType.RAW_BLACKVUE.value} or {FileType.BLACKVUE.value}, not both",
-        )
-
-    if DirectUploadFileType.RAW_CAMM in filetypes and FileType.CAMM in filetypes:
-        raise exceptions.MapillaryBadParameterError(
-            f"File types should contain either {DirectUploadFileType.RAW_CAMM.value} or {FileType.CAMM.value}, not both",
-        )
-
     import_paths: T.Sequence[Path]
     if isinstance(import_path, Path):
         import_paths = [import_path]
@@ -560,14 +535,7 @@ def upload(
                 f"Import file or directory not found: {path}"
             )
 
-    if {
-        DirectUploadFileType.RAW_CAMM,
-        DirectUploadFileType.RAW_BLACKVUE,
-        DirectUploadFileType.ZIP,
-    }.issuperset(filetypes):
-        metadatas = None
-    else:
-        metadatas = _load_descs(_metadatas_from_process, desc_path, import_paths)
+    metadatas = _load_descs(_metadatas_from_process, desc_path, import_paths)
 
     user_items = fetch_user_items(user_name, organization_key)
 
@@ -610,101 +578,79 @@ def upload(
         chunk_size=int(constants.UPLOAD_CHUNK_SIZE_MB * 1024 * 1024),
     )
 
-    # if more than one filetypes speficied, check filename suffixes,
-    # i.e. files not ended with .jpg or .mp4 will be ignored
-    check_file_suffix = len(filetypes) > 1
-
     try:
-        if FileType.IMAGE in filetypes:
-            image_paths = utils.find_images(
-                import_paths,
-                skip_subfolders=skip_subfolders,
-                check_file_suffix=check_file_suffix,
-            )
-            # find descs that match the image paths from the import paths
-            image_metadatas = [
-                metadata
-                for metadata in (metadatas or [])
-                if isinstance(metadata, types.ImageMetadata)
-            ]
-            specified_image_metadatas = _find_metadata_with_filename_existed_in(
-                image_metadatas, image_paths
+        image_paths = utils.find_images(import_paths, skip_subfolders=skip_subfolders)
+        # find descs that match the image paths from the import paths
+        image_metadatas = [
+            metadata
+            for metadata in (metadatas or [])
+            if isinstance(metadata, types.ImageMetadata)
+        ]
+        specified_image_metadatas = _find_metadata_with_filename_existed_in(
+            image_metadatas, image_paths
+        )
+        if specified_image_metadatas:
+            try:
+                clusters = mly_uploader.upload_images(
+                    specified_image_metadatas,
+                    event_payload={"file_type": FileType.IMAGE.value},
+                )
+            except Exception as ex:
+                raise UploadError(ex) from ex
+
+            if clusters:
+                LOG.debug("Uploaded to cluster: %s", clusters)
+
+        video_paths = utils.find_videos(import_paths, skip_subfolders=skip_subfolders)
+        video_metadatas = [
+            metadata
+            for metadata in (metadatas or [])
+            if isinstance(metadata, types.VideoMetadata)
+        ]
+        specified_video_metadatas = _find_metadata_with_filename_existed_in(
+            video_metadatas, video_paths
+        )
+        for idx, video_metadata in enumerate(specified_video_metadatas):
+            video_metadata.update_md5sum()
+            assert isinstance(video_metadata.md5sum, str), "md5sum should be updated"
+
+            # extract telemetry measurements from GoPro videos
+            telemetry_measurements: T.List[camm_parser.TelemetryMeasurement] = []
+            if MAPILLARY__EXPERIMENTAL_ENABLE_IMU == "YES":
+                if video_metadata.filetype is FileType.GOPRO:
+                    with video_metadata.filename.open("rb") as fp:
+                        telemetry_data = gpmf_parser.extract_telemetry_data(fp)
+                    if telemetry_data:
+                        telemetry_measurements.extend(telemetry_data.accl)
+                        telemetry_measurements.extend(telemetry_data.gyro)
+                        telemetry_measurements.extend(telemetry_data.magn)
+                    telemetry_measurements.sort(key=lambda m: m.time)
+
+            generator = camm_builder.camm_sample_generator2(
+                video_metadata, telemetry_measurements=telemetry_measurements
             )
-            if specified_image_metadatas:
+
+            with video_metadata.filename.open("rb") as src_fp:
+                camm_fp = simple_mp4_builder.transform_mp4(src_fp, generator)
+                event_payload: uploader.Progress = {
+                    "total_sequence_count": len(specified_video_metadatas),
+                    "sequence_idx": idx,
+                    "file_type": video_metadata.filetype.value,
+                    "import_path": str(video_metadata.filename),
+                }
                 try:
-                    clusters = mly_uploader.upload_images(
-                        specified_image_metadatas,
-                        event_payload={"file_type": FileType.IMAGE.value},
+                    cluster_id = mly_uploader.upload_stream(
+                        T.cast(T.BinaryIO, camm_fp),
+                        upload_api_v4.ClusterFileType.CAMM,
+                        video_metadata.md5sum,
+                        event_payload=event_payload,
                     )
                 except Exception as ex:
                     raise UploadError(ex) from ex
+                LOG.debug("Uploaded to cluster: %s", cluster_id)
 
-                if clusters:
-                    LOG.debug("Uploaded to cluster: %s", clusters)
-
-        supported = CAMM_CONVERTABLES.intersection(filetypes)
-        if supported:
-            video_paths = utils.find_videos(
-                import_paths,
-                skip_subfolders=skip_subfolders,
-                check_file_suffix=check_file_suffix,
-            )
-            video_metadatas = [
-                metadata
-                for metadata in (metadatas or [])
-                if isinstance(metadata, types.VideoMetadata)
-            ]
-            specified_video_metadatas = _find_metadata_with_filename_existed_in(
-                video_metadatas, video_paths
-            )
-            for idx, video_metadata in enumerate(specified_video_metadatas):
-                video_metadata.update_md5sum()
-                assert isinstance(
-                    video_metadata.md5sum, str
-                ), "md5sum should be updated"
-                generator = camm_builder.camm_sample_generator2(video_metadata)
-                with video_metadata.filename.open("rb") as src_fp:
-                    camm_fp = simple_mp4_builder.transform_mp4(src_fp, generator)
-                    event_payload: uploader.Progress = {
-                        "total_sequence_count": len(specified_video_metadatas),
-                        "sequence_idx": idx,
-                        "file_type": video_metadata.filetype.value,
-                        "import_path": str(video_metadata.filename),
-                    }
-                    try:
-                        cluster_id = mly_uploader.upload_stream(
-                            T.cast(T.BinaryIO, camm_fp),
-                            upload_api_v4.ClusterFileType.CAMM,
-                            video_metadata.md5sum,
-                            event_payload=event_payload,
-                        )
-                    except Exception as ex:
-                        raise UploadError(ex) from ex
-                    LOG.debug("Uploaded to cluster: %s", cluster_id)
-
-        if DirectUploadFileType.RAW_BLACKVUE in filetypes:
-            video_paths = utils.find_videos(
-                import_paths,
-                skip_subfolders=skip_subfolders,
-                check_file_suffix=check_file_suffix,
-            )
-            _upload_raw_blackvues_DEPRECATED(mly_uploader, video_paths)
-
-        if DirectUploadFileType.RAW_CAMM in filetypes:
-            video_paths = utils.find_videos(
-                import_paths,
-                skip_subfolders=skip_subfolders,
-                check_file_suffix=check_file_suffix,
-            )
-            _upload_raw_camm_DEPRECATED(mly_uploader, video_paths)
-
-        if DirectUploadFileType.ZIP in filetypes:
-            zip_paths = utils.find_zipfiles(
-                import_paths,
-                skip_subfolders=skip_subfolders,
-                check_file_suffix=check_file_suffix,
-            )
-            _upload_zipfiles(mly_uploader, zip_paths)
+        zip_paths = utils.find_zipfiles(import_paths, skip_subfolders=skip_subfolders)
+        _upload_zipfiles(mly_uploader, zip_paths)
 
     except UploadError as ex:
         inner_ex = ex.inner_ex
@@ -743,111 +689,6 @@ def upload(
         LOG.info("Nothing uploaded. Bye.")
 
 
-def _check_blackvue_DEPRECATED(video_path: Path) -> None:
-    # Skip in tests only because we don't have valid sample blackvue for tests
-    if os.getenv("MAPILLARY__DISABLE_BLACKVUE_CHECK") == "YES":
-        return
-
-    points = blackvue_parser.parse_gps_points(video_path)
-    if not points:
-        raise exceptions.MapillaryGPXEmptyError("No GPS found in the BlackVue video")
-
-    stationary = video_utils.is_video_stationary(
-        geo.get_max_distance_from_start([(p.lat, p.lon) for p in points])
-    )
-    if stationary:
-        raise exceptions.MapillaryStationaryVideoError("Stationary BlackVue video")
-
-
-def _upload_raw_blackvues_DEPRECATED(
-    mly_uploader: uploader.Uploader,
-    video_paths: T.Sequence[Path],
-) -> None:
-    for idx, video_path in enumerate(video_paths):
-        event_payload: uploader.Progress = {
-            "total_sequence_count": len(video_paths),
-            "sequence_idx": idx,
-            "file_type": DirectUploadFileType.RAW_BLACKVUE.value,
-            "import_path": str(video_path),
-        }
-
-        try:
-            _check_blackvue_DEPRECATED(video_path)
-        except Exception as ex:
-            LOG.warning(
-                "Skipping %s %s due to: %s",
-                DirectUploadFileType.RAW_BLACKVUE.value.upper(),
-                video_path.name,
-                ex,
-            )
-            continue
-
-        with video_path.open("rb") as fp:
-            upload_md5sum = utils.md5sum_fp(fp).hexdigest()
-            try:
-                cluster_id = mly_uploader.upload_stream(
-                    fp,
-                    upload_api_v4.ClusterFileType.BLACKVUE,
-                    upload_md5sum,
-                    event_payload=event_payload,
-                )
-            except Exception as ex:
-                raise UploadError(ex) from ex
-        LOG.debug("Uploaded to cluster: %s", cluster_id)
-
-
-def _check_camm_DEPRECATED(video_path: Path) -> None:
-    # Skip in tests only because we don't have valid sample CAMM for tests
-    if os.getenv("MAPILLARY__DISABLE_CAMM_CHECK") == "YES":
-        return
-
-    points = camm_parser.parse_gpx(video_path)
-    if not points:
-        raise exceptions.MapillaryGPXEmptyError("No GPS found in the CAMM video")
-
-    stationary = video_utils.is_video_stationary(
-        geo.get_max_distance_from_start([(p.lat, p.lon) for p in points])
-    )
-    if stationary:
-        raise exceptions.MapillaryStationaryVideoError("Stationary CAMM video")
-
-
-def _upload_raw_camm_DEPRECATED(
-    mly_uploader: uploader.Uploader,
-    video_paths: T.Sequence[Path],
-) -> None:
-    for idx, video_path in enumerate(video_paths):
-        event_payload: uploader.Progress = {
-            "total_sequence_count": len(video_paths),
-            "sequence_idx": idx,
-            "file_type": DirectUploadFileType.RAW_CAMM.value,
-            "import_path": str(video_path),
-        }
-        try:
-            _check_camm_DEPRECATED(video_path)
-        except Exception as ex:
-            LOG.warning(
-                "Skipping %s %s due to: %s",
-                DirectUploadFileType.RAW_CAMM.value.upper(),
-                video_path.name,
-                ex,
-            )
-            continue
-        try:
-            with video_path.open("rb") as fp:
-                upload_md5sum = utils.md5sum_fp(fp).hexdigest()
-                cluster_id = mly_uploader.upload_stream(
-                    fp,
-                    upload_api_v4.ClusterFileType.CAMM,
-                    upload_md5sum,
-                    event_payload=event_payload,
-                )
-        except Exception as ex:
-            raise UploadError(ex) from ex
-
-        LOG.debug("Uploaded to cluster: %s", cluster_id)
-
-
 def _upload_zipfiles(
     mly_uploader: uploader.Uploader,
     zip_paths: T.Sequence[Path],
@@ -856,7 +697,7 @@ def _upload_zipfiles(
         event_payload: uploader.Progress = {
             "total_sequence_count": len(zip_paths),
             "sequence_idx": idx,
-            "file_type": DirectUploadFileType.ZIP.value,
+            "file_type": FileType.ZIP.value,
             "import_path": str(zip_path),
         }
         try: