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

mapillary_tools/__init__.py

@@ -1 +1 @@
-VERSION = "0.13.1"
+VERSION = "0.13.2"

mapillary_tools/camm/camm_builder.py

@@ -1,7 +1,7 @@
 import io
 import typing as T
 
-from .. import geo, types
+from .. import geo, telemetry, types
 from ..mp4 import (
     construct_mp4_parser as cparser,
     mp4_sample_parser as sample_parser,
@@ -11,11 +11,62 @@ from ..mp4 import (
 from . import camm_parser
 
 
-def _build_camm_sample(measurement: camm_parser.TelemetryMeasurement) -> bytes:
-    for sample_entry_cls in camm_parser.SAMPLE_ENTRY_CLS_BY_CAMM_TYPE.values():
-        if sample_entry_cls.serializable(measurement):
-            return sample_entry_cls.serialize(measurement)
-    raise ValueError(f"Unsupported measurement type {type(measurement)}")
+TelemetryMeasurement = T.Union[
+    geo.Point,
+    telemetry.TelemetryMeasurement,
+]
+
+
+def _build_camm_sample(measurement: TelemetryMeasurement) -> bytes:
+    if isinstance(measurement, geo.Point):
+        return camm_parser.CAMMSampleData.build(
+            {
+                "type": camm_parser.CAMMType.MIN_GPS.value,
+                "data": [
+                    measurement.lat,
+                    measurement.lon,
+                    -1.0 if measurement.alt is None else measurement.alt,
+                ],
+            }
+        )
+    elif isinstance(measurement, telemetry.AccelerationData):
+        # Accelerometer reading in meters/second^2 along XYZ axes of the camera.
+        return camm_parser.CAMMSampleData.build(
+            {
+                "type": camm_parser.CAMMType.ACCELERATION.value,
+                "data": [
+                    measurement.x,
+                    measurement.y,
+                    measurement.z,
+                ],
+            }
+        )
+    elif isinstance(measurement, telemetry.GyroscopeData):
+        # Gyroscope signal in radians/seconds around XYZ axes of the camera. Rotation is positive in the counterclockwise direction.
+        return camm_parser.CAMMSampleData.build(
+            {
+                "type": camm_parser.CAMMType.GYRO.value,
+                "data": [
+                    measurement.x,
+                    measurement.y,
+                    measurement.z,
+                ],
+            }
+        )
+    elif isinstance(measurement, telemetry.MagnetometerData):
+        # Ambient magnetic field.
+        return camm_parser.CAMMSampleData.build(
+            {
+                "type": camm_parser.CAMMType.MAGNETIC_FIELD.value,
+                "data": [
+                    measurement.x,
+                    measurement.y,
+                    measurement.z,
+                ],
+            }
+        )
+    else:
+        raise ValueError(f"unexpected measurement type {type(measurement)}")
 
 
 def _create_edit_list_from_points(
@@ -70,19 +121,16 @@ def _create_edit_list_from_points(
 
 def _multiplex(
     points: T.Sequence[geo.Point],
-    measurements: T.Optional[T.List[camm_parser.TelemetryMeasurement]] = None,
-) -> T.List[camm_parser.TelemetryMeasurement]:
-    mutiplexed: T.List[camm_parser.TelemetryMeasurement] = [
-        *points,
-        *(measurements or []),
-    ]
+    measurements: T.Optional[T.List[telemetry.TelemetryMeasurement]] = None,
+) -> T.List[TelemetryMeasurement]:
+    mutiplexed: T.List[TelemetryMeasurement] = [*points, *(measurements or [])]
     mutiplexed.sort(key=lambda m: m.time)
 
     return mutiplexed
 
 
 def convert_telemetry_to_raw_samples(
-    measurements: T.Sequence[camm_parser.TelemetryMeasurement],
+    measurements: T.Sequence[TelemetryMeasurement],
     timescale: int,
 ) -> T.Generator[sample_parser.RawSample, None, None]:
     for idx, measurement in enumerate(measurements):
@@ -235,7 +283,7 @@ def create_camm_trak(
 
 def camm_sample_generator2(
     video_metadata: types.VideoMetadata,
-    telemetry_measurements: T.Optional[T.List[camm_parser.TelemetryMeasurement]] = None,
+    telemetry_measurements: T.Optional[T.List[telemetry.TelemetryMeasurement]] = None,
 ):
     def _f(
         fp: T.BinaryIO,

mapillary_tools/camm/camm_parser.py

@@ -1,6 +1,5 @@
 # pyre-ignore-all-errors[5, 11, 16, 21, 24, 58]
 
-import abc
 import dataclasses
 import io
 import logging
@@ -20,7 +19,9 @@ LOG = logging.getLogger(__name__)
 
 TelemetryMeasurement = T.Union[
     geo.Point,
-    telemetry.TelemetryMeasurement,
+    telemetry.AccelerationData,
+    telemetry.GyroscopeData,
+    telemetry.MagnetometerData,
 ]
 
 
@@ -35,305 +36,51 @@ class CAMMType(Enum):
     GPS = 6
     MAGNETIC_FIELD = 7
 
-    # Mapillary extensions are offset by 1024
-    # GoPro GPS is not compatible with CAMMType.GPS,
-    # so we use a new type to represent it
-    MLY_GOPRO_GPS = 1024 + 6
-
 
 # All fields are little-endian
 Float = C.Float32l
 Double = C.Float64l
 
-
-TTelemetry = T.TypeVar("TTelemetry", bound=TelemetryMeasurement)
-
-
-class CAMMSampleEntry(abc.ABC, T.Generic[TTelemetry]):
-    camm_type: CAMMType
-
-    construct: C.Struct
-
-    telemetry_cls: T.Type[TTelemetry]
-
-    @classmethod
-    def serializable(cls, data: T.Any, throw: bool = False) -> bool:
-        # Use "is" for exact type match, instead of isinstance
-        if type(data) is cls.telemetry_cls:
-            return True
-
-        if throw:
-            raise TypeError(
-                f"{cls} can not serialize {type(data)}: expect {cls.telemetry_cls}"
-            )
-        return False
-
-    @classmethod
-    @abc.abstractmethod
-    def serialize(cls, data: TTelemetry) -> bytes:
-        raise NotImplementedError
-
-    @classmethod
-    @abc.abstractmethod
-    def deserialize(cls, sample: Sample, data: T.Any) -> TTelemetry:
-        raise NotImplementedError
-
-
-class MinGPSSampleEntry(CAMMSampleEntry):
-    camm_type = CAMMType.MIN_GPS
-
-    construct = Double[3]  # type: ignore
-
-    telemetry_cls = geo.Point
-
-    @classmethod
-    def deserialize(cls, sample: Sample, data: T.Any) -> geo.Point:
-        return geo.Point(
-            time=sample.exact_time,
-            lat=data[0],
-            lon=data[1],
-            alt=data[2],
-            angle=None,
-        )
-
-    @classmethod
-    def serialize(cls, data: geo.Point) -> bytes:
-        cls.serializable(data, throw=True)
-
-        return CAMMSampleData.build(
-            {
-                "type": cls.camm_type.value,
-                "data": [
-                    data.lat,
-                    data.lon,
-                    -1.0 if data.alt is None else data.alt,
-                ],
-            }
-        )
-
-
-class GPSSampleEntry(CAMMSampleEntry):
-    camm_type: CAMMType = CAMMType.GPS
-
-    construct = C.Struct(
-        "time_gps_epoch" / Double,  # type: ignore
-        "gps_fix_type" / C.Int32sl,  # type: ignore
-        "latitude" / Double,  # type: ignore
-        "longitude" / Double,  # type: ignore
-        "altitude" / Float,  # type: ignore
-        "horizontal_accuracy" / Float,  # type: ignore
-        "vertical_accuracy" / Float,  # type: ignore
-        "velocity_east" / Float,  # type: ignore
-        "velocity_north" / Float,  # type: ignore
-        "velocity_up" / Float,  # type: ignore
-        "speed_accuracy" / Float,  # type: ignore
-    )
-
-    telemetry_cls = telemetry.CAMMGPSPoint
-
-    @classmethod
-    def deserialize(cls, sample: Sample, data: T.Any) -> telemetry.CAMMGPSPoint:
-        return telemetry.CAMMGPSPoint(
-            time=sample.exact_time,
-            lat=data.latitude,
-            lon=data.longitude,
-            alt=data.altitude,
-            angle=None,
-            time_gps_epoch=data.time_gps_epoch,
-            gps_fix_type=data.gps_fix_type,
-            horizontal_accuracy=data.horizontal_accuracy,
-            vertical_accuracy=data.vertical_accuracy,
-            velocity_east=data.velocity_east,
-            velocity_north=data.velocity_north,
-            velocity_up=data.velocity_up,
-            speed_accuracy=data.speed_accuracy,
-        )
-
-    @classmethod
-    def serialize(cls, data: telemetry.CAMMGPSPoint) -> bytes:
-        cls.serializable(data, throw=True)
-
-        return CAMMSampleData.build(
-            {
-                "type": cls.camm_type.value,
-                "data": {
-                    "time_gps_epoch": data.time_gps_epoch,
-                    "gps_fix_type": data.gps_fix_type,
-                    "latitude": data.lat,
-                    "longitude": data.lon,
-                    "altitude": -1.0 if data.alt is None else data.alt,
-                    "horizontal_accuracy": data.horizontal_accuracy,
-                    "vertical_accuracy": data.vertical_accuracy,
-                    "velocity_east": data.velocity_east,
-                    "velocity_north": data.velocity_north,
-                    "velocity_up": data.velocity_up,
-                    "speed_accuracy": data.speed_accuracy,
-                },
-            }
-        )
-
-
-class GoProGPSSampleEntry(CAMMSampleEntry):
-    camm_type: CAMMType = CAMMType.MLY_GOPRO_GPS
-
-    construct = C.Struct(
-        "latitude" / Double,  # type: ignore
-        "longitude" / Double,  # type: ignore
-        "altitude" / Float,  # type: ignore
-        "epoch_time" / Double,  # type: ignore
-        "fix" / C.Int32sl,  # type: ignore
-        "precision" / Float,  # type: ignore
-        "ground_speed" / Float,  # type: ignore
-    )
-
-    telemetry_cls = telemetry.GPSPoint
-
-    @classmethod
-    def deserialize(cls, sample: Sample, data: T.Any) -> telemetry.GPSPoint:
-        return telemetry.GPSPoint(
-            time=sample.exact_time,
-            lat=data.latitude,
-            lon=data.longitude,
-            alt=data.altitude,
-            angle=None,
-            epoch_time=data.epoch_time,
-            fix=telemetry.GPSFix(data.fix),
-            precision=data.precision,
-            ground_speed=data.ground_speed,
-        )
-
-    @classmethod
-    def serialize(cls, data: telemetry.GPSPoint) -> bytes:
-        cls.serializable(data, throw=True)
-
-        if data.fix is None:
-            gps_fix = telemetry.GPSFix.NO_FIX.value
-        else:
-            gps_fix = data.fix.value
-
-        return CAMMSampleData.build(
-            {
-                "type": cls.camm_type.value,
-                "data": {
-                    "latitude": data.lat,
-                    "longitude": data.lon,
-                    "altitude": -1.0 if data.alt is None else data.alt,
-                    "epoch_time": data.epoch_time,
-                    "fix": gps_fix,
-                    "precision": data.precision,
-                    "ground_speed": data.ground_speed,
-                },
-            }
-        )
-
-
-class AccelerationSampleEntry(CAMMSampleEntry):
-    camm_type: CAMMType = CAMMType.ACCELERATION
-
-    construct: C.Struct = Float[3]  # type: ignore
-
-    telemetry_cls = telemetry.AccelerationData
-
-    @classmethod
-    def deserialize(cls, sample: Sample, data: T.Any) -> telemetry.AccelerationData:
-        return telemetry.AccelerationData(
-            time=sample.exact_time,
-            x=data[0],
-            y=data[1],
-            z=data[2],
-        )
-
-    @classmethod
-    def serialize(cls, data: telemetry.AccelerationData) -> bytes:
-        cls.serializable(data, throw=True)
-
-        return CAMMSampleData.build(
-            {
-                "type": cls.camm_type.value,
-                "data": [data.x, data.y, data.z],
-            }
-        )
-
-
-class GyroscopeSampleEntry(CAMMSampleEntry):
-    camm_type: CAMMType = CAMMType.GYRO
-
-    construct: C.Struct = Float[3]  # type: ignore
-
-    telemetry_cls = telemetry.GyroscopeData
-
-    @classmethod
-    def deserialize(cls, sample: Sample, data: T.Any) -> telemetry.GyroscopeData:
-        return telemetry.GyroscopeData(
-            time=sample.exact_time,
-            x=data[0],
-            y=data[1],
-            z=data[2],
-        )
-
-    @classmethod
-    def serialize(cls, data: telemetry.GyroscopeData) -> bytes:
-        cls.serializable(data)
-
-        return CAMMSampleData.build(
-            {
-                "type": cls.camm_type.value,
-                "data": [data.x, data.y, data.z],
-            }
-        )
-
-
-class MagnetometerSampleEntry(CAMMSampleEntry):
-    camm_type: CAMMType = CAMMType.MAGNETIC_FIELD
-
-    construct: C.Struct = Float[3]  # type: ignore
-
-    telemetry_cls = telemetry.MagnetometerData
-
-    @classmethod
-    def deserialize(cls, sample: Sample, data: T.Any) -> telemetry.MagnetometerData:
-        return telemetry.MagnetometerData(
-            time=sample.exact_time,
-            x=data[0],
-            y=data[1],
-            z=data[2],
-        )
-
-    @classmethod
-    def serialize(cls, data: telemetry.MagnetometerData) -> bytes:
-        cls.serializable(data)
-
-        return CAMMSampleData.build(
-            {
-                "type": cls.camm_type.value,
-                "data": [data.x, data.y, data.z],
-            }
-        )
-
-
-SAMPLE_ENTRY_CLS_BY_CAMM_TYPE = {
-    sample_entry_cls.camm_type: sample_entry_cls
-    for sample_entry_cls in CAMMSampleEntry.__subclasses__()
-}
-assert len(SAMPLE_ENTRY_CLS_BY_CAMM_TYPE) == 6, SAMPLE_ENTRY_CLS_BY_CAMM_TYPE.keys()
-
-
 _SWITCH: T.Dict[int, C.Struct] = {
     # angle_axis
-    CAMMType.ANGLE_AXIS.value: Float[3],  # type: ignore
+    CAMMType.ANGLE_AXIS.value: Float[3],
     CAMMType.EXPOSURE_TIME.value: C.Struct(
-        "pixel_exposure_time" / C.Int32sl,  # type: ignore
-        "rolling_shutter_skew_time" / C.Int32sl,  # type: ignore
+        "pixel_exposure_time" / C.Int32sl,
+        "rolling_shutter_skew_time" / C.Int32sl,
     ),
+    # gyro
+    CAMMType.GYRO.value: Float[3],
+    # acceleration
+    CAMMType.ACCELERATION.value: Float[3],
     # position
-    CAMMType.POSITION.value: Float[3],  # type: ignore
-    **{t.value: cls.construct for t, cls in SAMPLE_ENTRY_CLS_BY_CAMM_TYPE.items()},
+    CAMMType.POSITION.value: Float[3],
+    # lat, lon, alt
+    CAMMType.MIN_GPS.value: Double[3],
+    CAMMType.GPS.value: C.Struct(
+        "time_gps_epoch" / Double,
+        "gps_fix_type" / C.Int32sl,
+        "latitude" / Double,
+        "longitude" / Double,
+        "altitude" / Float,
+        "horizontal_accuracy" / Float,
+        "vertical_accuracy" / Float,
+        "velocity_east" / Float,
+        "velocity_north" / Float,
+        "velocity_up" / Float,
+        "speed_accuracy" / Float,
+    ),
+    # magnetic_field
+    CAMMType.MAGNETIC_FIELD.value: Float[3],
 }
 
 CAMMSampleData = C.Struct(
     C.Padding(2),
     "type" / C.Int16ul,
-    "data" / C.Switch(C.this.type, _SWITCH),
+    "data"
+    / C.Switch(
+        C.this.type,
+        _SWITCH,
+    ),
 )
 
 
@@ -343,12 +90,46 @@ def _parse_telemetry_from_sample(
     fp.seek(sample.raw_sample.offset, io.SEEK_SET)
     data = fp.read(sample.raw_sample.size)
     box = CAMMSampleData.parse(data)
-
-    camm_type = CAMMType(box.type)  # type: ignore
-    SampleKlass = SAMPLE_ENTRY_CLS_BY_CAMM_TYPE.get(camm_type)
-    if SampleKlass is None:
-        return None
-    return SampleKlass.deserialize(sample, box.data)
+    if box.type == CAMMType.MIN_GPS.value:
+        return geo.Point(
+            time=sample.exact_time,
+            lat=box.data[0],
+            lon=box.data[1],
+            alt=box.data[2],
+            angle=None,
+        )
+    elif box.type == CAMMType.GPS.value:
+        # Not using box.data.time_gps_epoch as the point timestamp
+        # because it is from another clock
+        return geo.Point(
+            time=sample.exact_time,
+            lat=box.data.latitude,
+            lon=box.data.longitude,
+            alt=box.data.altitude,
+            angle=None,
+        )
+    elif box.type == CAMMType.ACCELERATION.value:
+        return telemetry.AccelerationData(
+            time=sample.exact_time,
+            x=box.data[0],
+            y=box.data[1],
+            z=box.data[2],
+        )
+    elif box.type == CAMMType.GYRO.value:
+        return telemetry.GyroscopeData(
+            time=sample.exact_time,
+            x=box.data[0],
+            y=box.data[1],
+            z=box.data[2],
+        )
+    elif box.type == CAMMType.MAGNETIC_FIELD.value:
+        return telemetry.MagnetometerData(
+            time=sample.exact_time,
+            x=box.data[0],
+            y=box.data[1],
+            z=box.data[2],
+        )
+    return None
 
 
 def _filter_telemetry_by_elst_segments(

mapillary_tools/telemetry.py

@@ -12,6 +12,14 @@ class GPSFix(Enum):
     FIX_3D = 3
 
 
+@dataclasses.dataclass
+class GPSPoint(Point):
+    epoch_time: T.Optional[float]
+    fix: T.Optional[GPSFix]
+    precision: T.Optional[float]
+    ground_speed: T.Optional[float]
+
+
 @dataclasses.dataclass(order=True)
 class TelemetryMeasurement:
     """Base class for all telemetry measurements.
@@ -24,26 +32,6 @@ class TelemetryMeasurement:
     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."""

mapillary_tools/upload.py

@@ -18,13 +18,14 @@ from . import (
     exceptions,
     history,
     ipc,
+    telemetry,
     types,
     upload_api_v4,
     uploader,
     utils,
     VERSION,
 )
-from .camm import camm_builder, camm_parser
+from .camm import camm_builder
 from .geotag import gpmf_parser
 from .mp4 import simple_mp4_builder
 from .types import FileType
@@ -615,7 +616,7 @@ def upload(
             assert isinstance(video_metadata.md5sum, str), "md5sum should be updated"
 
             # extract telemetry measurements from GoPro videos
-            telemetry_measurements: T.List[camm_parser.TelemetryMeasurement] = []
+            telemetry_measurements: T.List[telemetry.TelemetryMeasurement] = []
             if MAPILLARY__EXPERIMENTAL_ENABLE_IMU == "YES":
                 if video_metadata.filetype is FileType.GOPRO:
                     with video_metadata.filename.open("rb") as fp:

{mapillary_tools-0.13.1.dist-info → mapillary_tools-0.13.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapillary_tools
-Version: 0.13.1
+Version: 0.13.2
 Summary: Mapillary Image/Video Import Pipeline
 Home-page: https://github.com/mapillary/mapillary_tools
 Author: Mapillary

{mapillary_tools-0.13.1.dist-info → mapillary_tools-0.13.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-mapillary_tools/__init__.py,sha256=XBFY-aPf1nqJ7U8CvnYiXTRu3uDJLRQjOxibBTi-54U,19
+mapillary_tools/__init__.py,sha256=0qmTgs4HlmMGWxh_Upl_6EAbqBbUzX-Mw8rXWm5EO-U,19
 mapillary_tools/api_v4.py,sha256=zhRtgx3EnzgqtjziRhvFq3ONvsPaB9hROsuKFcf_pFo,5197
 mapillary_tools/authenticate.py,sha256=LCFcs6LqZmXaYkTUEKgGfmqytWdh5v_L3KXB48ojOZ4,3090
 mapillary_tools/config.py,sha256=jCjaK4jJaTY4AV4qf_b_tcxn5LA_uPsEWlGIdm2zw6g,2103
@@ -15,14 +15,14 @@ mapillary_tools/ipc.py,sha256=DwWQb9hNshx0bg0Fo5NjY0mXjs-FkbR6tIQmjMgMtmg,1089
 mapillary_tools/process_geotag_properties.py,sha256=w4hhv_c4sRydCK9QCO50sT2yo2zeVlY7dSdXQ93InFc,23159
 mapillary_tools/process_sequence_properties.py,sha256=5oYEjz9crnLVQtCkxbwn57TkeuHFbBh_zQXQSA4ENWg,11561
 mapillary_tools/sample_video.py,sha256=dpdX7bUNEmcrz-3gh3Y3awnTDX66pChbTKuF8qGfeCI,14400
-mapillary_tools/telemetry.py,sha256=3a7MvTH4Rr_mXp2NInubPIS8JFOuBeQC7PC2prfXNfI,1559
+mapillary_tools/telemetry.py,sha256=WpBGPF_GMPjM_EFqXIutFtpDFL9wj7yEzGNGnfQZUo8,1255
 mapillary_tools/types.py,sha256=6kww2UdKM6YzabYbc862BYzEWtxL2hhxCRFfeDiUtF0,22074
-mapillary_tools/upload.py,sha256=ab1WEut6qv352njWKtNbUXmV8KShlApOjcwb1FpcC_Q,24439
+mapillary_tools/upload.py,sha256=8dQ3ZWsjau1_xZN3ssjGGkBnLKbKIhjC91-zWstYlD8,24439
 mapillary_tools/upload_api_v4.py,sha256=1WvoUis92KDXbqfoyvyyDmiCqwXezYkMJZhnYaVm3BA,8560
 mapillary_tools/uploader.py,sha256=VieDKi51wdXTIhN7x_mcuQeHESUyFlF5cgB-TAnF4g0,14093
 mapillary_tools/utils.py,sha256=VNtK1tAb3Hh8y3P5e5Y3iewREkIoLDa3C2myRYcF2lY,5970
-mapillary_tools/camm/camm_builder.py,sha256=x4WF-n6zOEUhK1Poo7du004-7DQhjnf598ZNfM3r7iA,9075
-mapillary_tools/camm/camm_parser.py,sha256=ARwImVcXY1FckCnPLPoyYAuODJb5iZI0hlQurAIeiWQ,16473
+mapillary_tools/camm/camm_builder.py,sha256=TXZfhu3xGjtrLEWnB14D7aSOrHOoSJef24YSLApiIfY,10631
+mapillary_tools/camm/camm_parser.py,sha256=RaCWeLvS_AyHD6B6wDUu9DAsdfByVHMAPTqEqjtFibE,9734
 mapillary_tools/commands/__init__.py,sha256=41CFrPLGlG3566uhxssEF3TGAtSpADFPPcDMHbViU0E,171
 mapillary_tools/commands/__main__.py,sha256=VdWkx1ekPH-88Ybe78IcO9FWpZ5cUhsbGRw7LuzQObU,4832
 mapillary_tools/commands/authenticate.py,sha256=4aVvAQal_mqtm2NEMBt5aKLahi0iRdO8b7WSBf6jokA,1136
@@ -67,9 +67,9 @@ mapillary_tools/video_data_extraction/extractors/generic_video_parser.py,sha256=
 mapillary_tools/video_data_extraction/extractors/gopro_parser.py,sha256=IVnTyquSraTUaG9rxbJfVWc1-drdY5PaHn5urh3IBk4,1325
 mapillary_tools/video_data_extraction/extractors/gpx_parser.py,sha256=FNrdnXl48k8I1I5fGwYsClhfFEHVsooRLRboUYECv3I,3811
 mapillary_tools/video_data_extraction/extractors/nmea_parser.py,sha256=raSXavBvP-0LJCB_TwLL0mOv2uHSsB744igTsaKAaGc,658
-mapillary_tools-0.13.1.dist-info/LICENSE,sha256=l2D8cKfFmmJq_wcVq_JElPJrlvWQOzNWx7gMLINucxc,1292
-mapillary_tools-0.13.1.dist-info/METADATA,sha256=K1pmlXXrkP_o1qFddzeG6RyXGt6HqVKhU8aLhIVUK_w,19758
-mapillary_tools-0.13.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapillary_tools-0.13.1.dist-info/entry_points.txt,sha256=A3f3LP-BO_P-U8Y29QfpT4jx6Mjk3sXjTi2Yew4bvj8,75
-mapillary_tools-0.13.1.dist-info/top_level.txt,sha256=FbDkMgOrt1S70ho1WSBrOwzKOSkJFDwwqFOoY5-527s,16
-mapillary_tools-0.13.1.dist-info/RECORD,,
+mapillary_tools-0.13.2.dist-info/LICENSE,sha256=l2D8cKfFmmJq_wcVq_JElPJrlvWQOzNWx7gMLINucxc,1292
+mapillary_tools-0.13.2.dist-info/METADATA,sha256=2tmLjwx7V2QhrErmOK9uL1McwGYAaHqXDw-wTIS1N3w,19758
+mapillary_tools-0.13.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapillary_tools-0.13.2.dist-info/entry_points.txt,sha256=A3f3LP-BO_P-U8Y29QfpT4jx6Mjk3sXjTi2Yew4bvj8,75
+mapillary_tools-0.13.2.dist-info/top_level.txt,sha256=FbDkMgOrt1S70ho1WSBrOwzKOSkJFDwwqFOoY5-527s,16
+mapillary_tools-0.13.2.dist-info/RECORD,,