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

mapillary_tools/sample_video.py

@@ -19,7 +19,7 @@ LOG = logging.getLogger(__name__)
 
 def _normalize_path(
     video_import_path: Path, skip_subfolders: bool
-) -> T.Tuple[Path, T.List[Path]]:
+) -> tuple[Path, list[Path]]:
     if video_import_path.is_dir():
         video_list = utils.find_videos(
             [video_import_path], skip_subfolders=skip_subfolders
@@ -51,7 +51,7 @@ def sample_video(
     video_sample_distance=constants.VIDEO_SAMPLE_DISTANCE,
     video_sample_interval=constants.VIDEO_SAMPLE_INTERVAL,
     video_duration_ratio=constants.VIDEO_DURATION_RATIO,
-    video_start_time: T.Optional[str] = None,
+    video_start_time: str | None = None,
     skip_sample_errors: bool = False,
     rerun: bool = False,
 ) -> None:
@@ -62,7 +62,7 @@ def sample_video(
             f"Expect either non-negative video_sample_distance or positive video_sample_interval but got {video_sample_distance} and {video_sample_interval} respectively"
         )
 
-    video_start_time_dt: T.Optional[datetime.datetime] = None
+    video_start_time_dt: datetime.datetime | None = None
     if video_start_time is not None:
         try:
             video_start_time_dt = types.map_capture_time_to_datetime(video_start_time)
@@ -179,7 +179,7 @@ def _sample_single_video_by_interval(
     sample_dir: Path,
     sample_interval: float,
     duration_ratio: float,
-    start_time: T.Optional[datetime.datetime] = None,
+    start_time: datetime.datetime | None = None,
 ) -> None:
     ffmpeg = ffmpeglib.FFMPEG(constants.FFMPEG_PATH, constants.FFPROBE_PATH)
 
@@ -219,7 +219,7 @@ def _sample_video_stream_by_distance(
     points: T.Sequence[geo.Point],
     video_track_parser: mp4_sample_parser.TrackBoxParser,
     sample_distance: float,
-) -> T.Dict[int, T.Tuple[mp4_sample_parser.Sample, geo.Point]]:
+) -> dict[int, tuple[mp4_sample_parser.Sample, geo.Point]]:
     """
     Locate video frames along the track (points), then resample them by the minimal sample_distance, and return the sparse frames.
     """
@@ -275,7 +275,7 @@ def _sample_single_video_by_distance(
     video_path: Path,
     sample_dir: Path,
     sample_distance: float,
-    start_time: T.Optional[datetime.datetime] = None,
+    start_time: datetime.datetime | None = None,
 ) -> None:
     ffmpeg = ffmpeglib.FFMPEG(constants.FFMPEG_PATH, constants.FFPROBE_PATH)
 
@@ -290,9 +290,9 @@ def _sample_single_video_by_distance(
 
     LOG.info("Extracting video metdata")
 
-    video_metadatas = geotag_videos_from_video.GeotagVideosFromVideo(
+    video_metadatas = geotag_videos_from_video.GeotagVideosFromVideo().to_description(
         [video_path]
-    ).to_description()
+    )
     assert len(video_metadatas) == 1, "expect 1 video metadata"
     video_metadata = video_metadatas[0]
     if isinstance(video_metadata, types.ErrorMetadata):

mapillary_tools/telemetry.py

@@ -1,5 +1,6 @@
+from __future__ import annotations
+
 import dataclasses
-import typing as T
 from enum import Enum, unique
 
 from .geo import Point
@@ -26,10 +27,10 @@ class TimestampedMeasurement:
 
 @dataclasses.dataclass
 class GPSPoint(TimestampedMeasurement, Point):
-    epoch_time: T.Optional[float]
-    fix: T.Optional[GPSFix]
-    precision: T.Optional[float]
-    ground_speed: T.Optional[float]
+    epoch_time: float | None
+    fix: GPSFix | None
+    precision: float | None
+    ground_speed: float | None
 
 
 @dataclasses.dataclass

mapillary_tools/types.py

@@ -53,23 +53,20 @@ NATIVE_VIDEO_FILETYPES = {
 @dataclasses.dataclass
 class ImageMetadata(geo.Point):
     filename: Path
-    # if None or absent, it will be calculated
-    md5sum: T.Optional[str] = None
-    # filetype: is always FileType.IMAGE
-    width: T.Optional[int] = None
-    height: T.Optional[int] = None
-    MAPSequenceUUID: T.Optional[str] = None
-    MAPDeviceMake: T.Optional[str] = None
-    MAPDeviceModel: T.Optional[str] = None
-    MAPGPSAccuracyMeters: T.Optional[float] = None
-    MAPCameraUUID: T.Optional[str] = None
-    MAPOrientation: T.Optional[int] = None
-    # deprecated since v0.10.0; keep here for compatibility
-    MAPMetaTags: T.Optional[T.Dict] = None
-    MAPFilename: T.Optional[str] = None
-    filesize: T.Optional[int] = None
-
-    def update_md5sum(self, image_data: T.Optional[T.BinaryIO] = None) -> None:
+    md5sum: str | None = None
+    width: int | None = None
+    height: int | None = None
+    MAPSequenceUUID: str | None = None
+    MAPDeviceMake: str | None = None
+    MAPDeviceModel: str | None = None
+    MAPGPSAccuracyMeters: float | None = None
+    MAPCameraUUID: str | None = None
+    MAPOrientation: int | None = None
+    MAPMetaTags: dict | None = None
+    MAPFilename: str | None = None
+    filesize: int | None = None
+
+    def update_md5sum(self, image_data: T.BinaryIO | None = None) -> None:
         if self.md5sum is None:
             if image_data is None:
                 with self.filename.open("rb") as fp:
@@ -87,13 +84,12 @@ class ImageMetadata(geo.Point):
 @dataclasses.dataclass
 class VideoMetadata:
     filename: Path
-    # if None or absent, it will be calculated
     filetype: FileType
     points: T.Sequence[geo.Point]
-    md5sum: T.Optional[str] = None
-    make: T.Optional[str] = None
-    model: T.Optional[str] = None
-    filesize: T.Optional[int] = None
+    md5sum: str | None = None
+    make: str | None = None
+    model: str | None = None
+    filesize: int | None = None
 
     def update_md5sum(self) -> None:
         if self.md5sum is None:
@@ -144,7 +140,7 @@ def combine_filetype_filters(
 
 
 class UserItem(TypedDict, total=False):
-    MAPOrganizationKey: T.Union[int, str]
+    MAPOrganizationKey: int | str
     # Not in use. Keep here for back-compatibility
     MAPSettingsUsername: str
     MAPSettingsUserKey: str
@@ -183,23 +179,22 @@ class ImageDescription(_SequenceOnly, _Image, MetaProperties, total=True):
     # filename is required
     filename: str
     # if None or absent, it will be calculated
-    md5sum: T.Optional[str]
+    md5sum: str | None
     filetype: Literal["image"]
-    filesize: T.Optional[int]
+    filesize: int | None
 
 
 class _VideoDescriptionRequired(TypedDict, total=True):
     filename: str
-    # if None or absent, it will be calculated
-    md5sum: T.Optional[str]
+    md5sum: str | None
     filetype: str
-    MAPGPSTrack: T.List[T.Sequence[T.Union[float, int, None]]]
+    MAPGPSTrack: list[T.Sequence[float | int | None]]
 
 
 class VideoDescription(_VideoDescriptionRequired, total=False):
     MAPDeviceMake: str
     MAPDeviceModel: str
-    filesize: T.Optional[int]
+    filesize: int | None
 
 
 class _ErrorDescription(TypedDict, total=False):
@@ -207,7 +202,7 @@ class _ErrorDescription(TypedDict, total=False):
     type: str
     message: str
     # vars is optional
-    vars: T.Dict
+    vars: dict
 
 
 class _ImageDescriptionErrorRequired(TypedDict, total=True):
@@ -238,7 +233,7 @@ def separate_errors(
 
 
 def _describe_error_desc(
-    exc: Exception, filename: Path, filetype: T.Optional[FileType]
+    exc: Exception, filename: Path, filetype: FileType | None
 ) -> ImageDescriptionError:
     err: _ErrorDescription = {
         "type": exc.__class__.__name__,
@@ -397,7 +392,7 @@ VideoDescriptionSchema = {
 }
 
 
-def merge_schema(*schemas: T.Dict) -> T.Dict:
+def merge_schema(*schemas: dict) -> dict:
     for s in schemas:
         assert s.get("type") == "object", "must be all object schemas"
     properties = {}
@@ -507,7 +502,7 @@ def validate_video_desc(desc: T.Any) -> None:
         raise exceptions.MapillaryMetadataValidationError(ex.message) from ex
 
 
-def datetime_to_map_capture_time(time: T.Union[datetime.datetime, int, float]) -> str:
+def datetime_to_map_capture_time(time: datetime.datetime | int | float) -> str:
     if isinstance(time, (float, int)):
         dt = datetime.datetime.fromtimestamp(time, datetime.timezone.utc)
         # otherwise it will be assumed to be in local time
@@ -608,7 +603,7 @@ def from_desc(desc):
 
 
 def _from_image_desc(desc) -> ImageMetadata:
-    kwargs: T.Dict = {}
+    kwargs: dict = {}
     for k, v in desc.items():
         if k not in [
             "filename",
@@ -638,7 +633,7 @@ def _from_image_desc(desc) -> ImageMetadata:
     )
 
 
-def _encode_point(p: geo.Point) -> T.Sequence[T.Union[float, int, None]]:
+def _encode_point(p: geo.Point) -> T.Sequence[float | int | None]:
     entry = [
         int(p.time * 1000),
         round(p.lon, _COORDINATES_PRECISION),
@@ -743,10 +738,10 @@ def desc_file_to_exif(
 
 
 def group_and_sort_images(
-    metadatas: T.Sequence[ImageMetadata],
-) -> T.Dict[str, T.List[ImageMetadata]]:
+    metadatas: T.Iterable[ImageMetadata],
+) -> dict[str, list[ImageMetadata]]:
     # group metadatas by uuid
-    sequences_by_uuid: T.Dict[str, T.List[ImageMetadata]] = {}
+    sequences_by_uuid: dict[str, list[ImageMetadata]] = {}
     missing_sequence_uuid = str(uuid.uuid4())
     for metadata in metadatas:
         if metadata.MAPSequenceUUID is None:

mapillary_tools/utils.py

@@ -9,9 +9,7 @@ from pathlib import Path
 
 # Use "hashlib._Hash" instead of hashlib._Hash because:
 # AttributeError: module 'hashlib' has no attribute '_Hash'
-def md5sum_fp(
-    fp: T.IO[bytes], md5: T.Optional["hashlib._Hash"] = None
-) -> "hashlib._Hash":
+def md5sum_fp(fp: T.IO[bytes], md5: "hashlib._Hash | None" = None) -> "hashlib._Hash":
     if md5 is None:
         md5 = hashlib.md5()
     while True:
@@ -93,12 +91,12 @@ def filter_video_samples(
 
 
 def find_all_image_samples(
-    image_paths: T.Sequence[Path], video_paths: T.Sequence[Path]
-) -> T.Dict[Path, T.List[Path]]:
+    image_paths: T.Iterable[Path], video_paths: T.Iterable[Path]
+) -> dict[Path, list[Path]]:
     # TODO: not work with the same filenames, e.g. foo/hello.mp4 and bar/hello.mp4
     video_basenames = {path.name: path for path in video_paths}
 
-    image_samples_by_video_path: T.Dict[Path, T.List[Path]] = {}
+    image_samples_by_video_path: dict[Path, list[Path]] = {}
     for image_path in image_paths:
         # If you want to walk an arbitrary filesystem path upwards,
         # it is recommended to first call Path.resolve() so as to resolve symlinks and eliminate “..” components.
@@ -115,7 +113,7 @@ def find_all_image_samples(
 
 
 def deduplicate_paths(paths: T.Iterable[Path]) -> T.Generator[Path, None, None]:
-    resolved_paths: T.Set[Path] = set()
+    resolved_paths: set[Path] = set()
     for p in paths:
         resolved = p.resolve()
         if resolved not in resolved_paths:
@@ -124,10 +122,10 @@ def deduplicate_paths(paths: T.Iterable[Path]) -> T.Generator[Path, None, None]:
 
 
 def find_images(
-    import_paths: T.Sequence[Path],
+    import_paths: T.Iterable[Path],
     skip_subfolders: bool = False,
-) -> T.List[Path]:
-    image_paths: T.List[Path] = []
+) -> list[Path]:
+    image_paths: list[Path] = []
     for path in import_paths:
         if path.is_dir():
             image_paths.extend(
@@ -142,10 +140,10 @@ def find_images(
 
 
 def find_videos(
-    import_paths: T.Sequence[Path],
+    import_paths: T.Iterable[Path],
     skip_subfolders: bool = False,
-) -> T.List[Path]:
-    video_paths: T.List[Path] = []
+) -> list[Path]:
+    video_paths: list[Path] = []
     for path in import_paths:
         if path.is_dir():
             video_paths.extend(
@@ -160,10 +158,10 @@ def find_videos(
 
 
 def find_zipfiles(
-    import_paths: T.Sequence[Path],
+    import_paths: T.Iterable[Path],
     skip_subfolders: bool = False,
-) -> T.List[Path]:
-    zip_paths: T.List[Path] = []
+) -> list[Path]:
+    zip_paths: list[Path] = []
     for path in import_paths:
         if path.is_dir():
             zip_paths.extend(
@@ -177,8 +175,8 @@ def find_zipfiles(
     return list(deduplicate_paths(zip_paths))
 
 
-def find_xml_files(import_paths: T.Sequence[Path]) -> T.List[Path]:
-    xml_paths: T.List[Path] = []
+def find_xml_files(import_paths: T.Iterable[Path]) -> list[Path]:
+    xml_paths: list[Path] = []
     for path in import_paths:
         if path.is_dir():
             # XML could be hidden in hidden folders

{mapillary_tools-0.14.0a1.dist-info → mapillary_tools-0.14.0a2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapillary_tools
-Version: 0.14.0a1
+Version: 0.14.0a2
 Summary: Mapillary Image/Video Import Pipeline
 Home-page: https://github.com/mapillary/mapillary_tools
 Author: Mapillary

mapillary_tools-0.14.0a2.dist-info/RECORD

@@ -0,0 +1,72 @@
+mapillary_tools/__init__.py,sha256=AdfWnUWJogoEJm_EqofQxlG8NYL78h0B0M3Igr2xQpE,21
+mapillary_tools/api_v4.py,sha256=uvz48tb2HaM1wfomaUR0V2HdId39HoxnQAc1WWgptvo,10091
+mapillary_tools/authenticate.py,sha256=KG3p_7D4D7nUvrGRLGp56_ogLy7JUHzkGSpBw8V70LY,11091
+mapillary_tools/blackvue_parser.py,sha256=Gmz3M1cvBmB2W3Pme6x3w2yuixDpKiTOkQe82iPXr2s,3613
+mapillary_tools/config.py,sha256=uoNW5PnB1a2TW959KmNSYgJ1Y4_trn0xxPHJQ6T-cbI,2633
+mapillary_tools/constants.py,sha256=BVnAlqz2XJfodNXsJfsGIV0L4P_3--oOgw1pR38D-Ls,3770
+mapillary_tools/exceptions.py,sha256=P8vEh3pfOqyzJgOiQiRAcWsZTrcawjic7i4v3k335tM,2411
+mapillary_tools/exif_read.py,sha256=gagyRv06RkZPRHQhyV-5-uQzxHgxOsVqUX2aC8QmCyM,32145
+mapillary_tools/exif_write.py,sha256=Ue0ngLKCfuLQM7X4h5ETjSInUDcyEBWOR6v8ko7DJ1o,8769
+mapillary_tools/exiftool_read.py,sha256=5uatYE9mgbg2d9NAnPfX22nSRBjXhJ9ayMqNMd4QwGM,15779
+mapillary_tools/exiftool_read_video.py,sha256=WXpw7CI7B4daJHRWzzVXAyVgDrFN8nPxQ3UPcVQqRJM,14760
+mapillary_tools/exiftool_runner.py,sha256=J04V0Y70kTiGE2q2m5TKWfORd0hmYNmAsmrZxb34S3s,2316
+mapillary_tools/ffmpeg.py,sha256=tRgdChGHAhHXjZPivDuVImubrJWfSDZDBZ7mSzkeABc,15698
+mapillary_tools/geo.py,sha256=MSfkjSAgTAeuBqncQ8-QXvDuJ7ar7bTt5P_e9HDIgVs,10604
+mapillary_tools/history.py,sha256=8ng2WHXadzbE5gnsoik6gbmRoEXTuGPp997RBiiWy08,1649
+mapillary_tools/ipc.py,sha256=DwWQb9hNshx0bg0Fo5NjY0mXjs-FkbR6tIQmjMgMtmg,1089
+mapillary_tools/process_geotag_properties.py,sha256=f0Up7yNzgLn32VBFMzoMT6SCsdzFUFYmloOsVHmK5k0,13920
+mapillary_tools/process_sequence_properties.py,sha256=LSYyCH1nmEcYWWZKF1bOYh4hqjwXdz4FY9TqQQfW7AU,23418
+mapillary_tools/sample_video.py,sha256=MwTr2bY5RFnOFThNPg3YiyXCXzWOlTXKq7EOri_W3Vw,13880
+mapillary_tools/telemetry.py,sha256=lL6qQbtOZft4DZZrCNK3njlwHT_30zLyYS_YRN5pgHY,1568
+mapillary_tools/types.py,sha256=0O4fzbwwoT6Znp2Ag1ptjzBKGb3E_RhGyqUUZu6gkPY,23078
+mapillary_tools/upload.py,sha256=exQeEh3jpys94k-3QDT-4xoeJ_lAHbQBoy749hbPfnA,24878
+mapillary_tools/upload_api_v4.py,sha256=dTEpQDnV11TyPf5hefd-FVeEfw7WEVYyZcIUJttUEp0,6417
+mapillary_tools/uploader.py,sha256=xPEszuXlgcgCklGfsgL8qN1ozsFuU4rLT4jocMD2dVI,18694
+mapillary_tools/utils.py,sha256=ft-TrqgwWq1a-HpQqnCWIortZbjjTOywllPi8HBA3FU,6642
+mapillary_tools/camm/camm_builder.py,sha256=ub6Z9ijep8zAo1NOlU51Gxk95kQ2vfN58YgVCLmNMRk,9211
+mapillary_tools/camm/camm_parser.py,sha256=aNHP65hNXYQBWBTfhaj_S5XYzmAHhjwcAfGhbm83__o,18043
+mapillary_tools/commands/__init__.py,sha256=41CFrPLGlG3566uhxssEF3TGAtSpADFPPcDMHbViU0E,171
+mapillary_tools/commands/__main__.py,sha256=5gwngScbvrSNF2S1CA5w_qZgxW_kFevu5NQ89U9u1ZE,5046
+mapillary_tools/commands/authenticate.py,sha256=yqtpHMYzkyBrrchj6MARxB0ywUTfqCEOPkMbkyaO9Ks,1344
+mapillary_tools/commands/process.py,sha256=Japc6_P0B_8HzoM8_82P3_YAiyBBaQZXS9TZF46pbMM,9771
+mapillary_tools/commands/process_and_upload.py,sha256=-RB_86a5xKfQ7Ye79dh6yyJQpZg2xnJZAWOJsUNbUtQ,1041
+mapillary_tools/commands/sample_video.py,sha256=jtnrZrsqqv5eYV1chNTas7RhfbeKBqbAUDUNRFjF01w,3253
+mapillary_tools/commands/upload.py,sha256=YnA1iSvNcFeV7kMs1p4TdaPBUWUFYb7X-vFhQeSz0eI,2005
+mapillary_tools/commands/video_process.py,sha256=-wQeeIwWXPmy81HQHam5A0huMLRHknkEFa_V1OwElU4,890
+mapillary_tools/commands/video_process_and_upload.py,sha256=hOyq9L9TuD0JcqFSOOxdCdgsBA1iJ6fu1TtDbsUr8sI,1088
+mapillary_tools/commands/zip.py,sha256=DVQuMLpbstwiy5o4pU_fBvM6eORuFjLeySd80AhHKU0,991
+mapillary_tools/geotag/base.py,sha256=JdLBXHlC22gqmZkyfAykv1osrzitWoCK8RFHdCd5qlc,4864
+mapillary_tools/geotag/factory.py,sha256=2HIOnUtfxsgWn2GF0PbbgHq3Tzyssrl4T39YDMtN42U,9564
+mapillary_tools/geotag/geotag_images_from_exif.py,sha256=a5fDOp4tlEoVNwrOCJBrvSPzu1LbyxL4RNrNDD0tPP0,608
+mapillary_tools/geotag/geotag_images_from_exiftool.py,sha256=YxMFwv3A35Hh9tcGX1B1Si_m6TNep54SL5XFAQadQh0,5302
+mapillary_tools/geotag/geotag_images_from_gpx.py,sha256=b_4xKVUt0HLIjNN-v7ZVddXDZ9cdxAfecB5Dj2X6XQE,6353
+mapillary_tools/geotag/geotag_images_from_gpx_file.py,sha256=HYQkwak32YBDuRrTNiIZOmE3iImCRc22HWWb485WRS4,1121
+mapillary_tools/geotag/geotag_images_from_nmea_file.py,sha256=J8xj6ch9bMPRubJtsRGeb3sb9LyB0ZYy65NPEOVkUe8,1597
+mapillary_tools/geotag/geotag_images_from_video.py,sha256=5_qVgLt_DKl7oQrr9kWxi4iM143_HPAx5Lau-3fB7t4,3136
+mapillary_tools/geotag/geotag_videos_from_exiftool.py,sha256=7chO_tb7ECsBlOkFhiXQ4fhomVPkfBOWtdfzXGpsJes,3168
+mapillary_tools/geotag/geotag_videos_from_gpx.py,sha256=k4a1imUVLg2yDqggCwTSqjvY7jXQd3E-vniBuJj2d4M,1017
+mapillary_tools/geotag/geotag_videos_from_video.py,sha256=T8XS4lVF2Wz4eDXNi5Vt076M5dxjxJXibVrWhqVvErs,863
+mapillary_tools/geotag/options.py,sha256=7Fz0QoCMyZZbhkKvY4HPNWYfnKdQSWE2oRXb7jYZhmA,4336
+mapillary_tools/geotag/utils.py,sha256=0DenLVCLP-GZdk0rCFP0V1tjMGK4XAvYro3I_1RKgCA,1733
+mapillary_tools/geotag/image_extractors/base.py,sha256=XoNrLCbJtd-MN-snbhv6zyr6zBfJRoJkntV0ptrh6qg,358
+mapillary_tools/geotag/image_extractors/exif.py,sha256=cCUegbFqWxjAP4oOP1nZmwoJISWeKgjGO8h_t7nucHs,2079
+mapillary_tools/geotag/image_extractors/exiftool.py,sha256=zokJmf-D2rPvASRJs3dZzEu7j82igpMOr4SE6Z1nsVg,497
+mapillary_tools/geotag/video_extractors/base.py,sha256=_3B37T-m2HGy77avAF8i_kEatIyQqFfBu49qVnx_0PU,357
+mapillary_tools/geotag/video_extractors/exiftool.py,sha256=CB49qZqgmxECma-N5757aEn37xXRbCNRcT4o-Ip7dCw,2312
+mapillary_tools/geotag/video_extractors/gpx.py,sha256=Oycdn74CNiq1j8dAq7O9YiVNTun2mFWRH9VTUn_viRk,4114
+mapillary_tools/geotag/video_extractors/native.py,sha256=XChOyDvrf88Vu8ED-FTT_hzax2FllokanszSW4Q2MEA,5702
+mapillary_tools/gpmf/gpmf_gps_filter.py,sha256=7cg8wEjC1DrujKY76FZguXsaPqTRkG9-t32OeuOJQIc,2755
+mapillary_tools/gpmf/gpmf_parser.py,sha256=uOVXkwJxC3Y2YfTdzUDpt7Bh0pdVqa5u0WUuv7pEJEs,24670
+mapillary_tools/gpmf/gps_filter.py,sha256=zhXkuvr0Dd1bxGTYBwvk6P7xasY_RLuWjHaX7CdBayc,3796
+mapillary_tools/mp4/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapillary_tools/mp4/construct_mp4_parser.py,sha256=ArJ5C8iWJhHNPFkN048DXh6EwQ8LMfnTMwoNlKV9NoI,17191
+mapillary_tools/mp4/io_utils.py,sha256=KZaJTlgFS27Oh3pcA5MKXYFoCifqgFaEZJyU6lb1jc4,5416
+mapillary_tools/mp4/mp4_sample_parser.py,sha256=0ILTq8M6mXFTI3agKgljpvO9uYa7HXGUGZpdHT8a6ac,11547
+mapillary_tools/mp4/simple_mp4_builder.py,sha256=9TUGk1hzI6mQFN1P30jwHL3dCYz3Zz7rsm8UBvMAqMc,12734
+mapillary_tools/mp4/simple_mp4_parser.py,sha256=g3vvPhBoNu7anhVzC5_XQCV7IwfRWro1vJ6d6GyDkHE,6315
+mapillary_tools-0.14.0a2.dist-info/licenses/LICENSE,sha256=l2D8cKfFmmJq_wcVq_JElPJrlvWQOzNWx7gMLINucxc,1292
+mapillary_tools-0.14.0a2.dist-info/METADATA,sha256=UDVbKn5kqizwZmE70erGYDOnSz8sg9CuTd81GHSWtDI,19782
+mapillary_tools-0.14.0a2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+mapillary_tools-0.14.0a2.dist-info/entry_points.txt,sha256=A3f3LP-BO_P-U8Y29QfpT4jx6Mjk3sXjTi2Yew4bvj8,75
+mapillary_tools-0.14.0a2.dist-info/top_level.txt,sha256=FbDkMgOrt1S70ho1WSBrOwzKOSkJFDwwqFOoY5-527s,16
+mapillary_tools-0.14.0a2.dist-info/RECORD,,

mapillary_tools/geotag/__init__.py

@@ -1 +0,0 @@
-from .. import geo  # noqa: F401

mapillary_tools/geotag/geotag_images_from_exiftool_both_image_and_video.py

@@ -1,77 +0,0 @@
-from __future__ import annotations
-
-import logging
-import typing as T
-from pathlib import Path
-
-from .. import exiftool_read, types, utils
-from . import (
-    geotag_images_from_exiftool,
-    geotag_images_from_video,
-    geotag_videos_from_exiftool_video,
-)
-from .geotag_from_generic import GeotagImagesFromGeneric
-
-
-LOG = logging.getLogger(__name__)
-
-
-class GeotagImagesFromExifToolBothImageAndVideo(GeotagImagesFromGeneric):
-    def __init__(
-        self,
-        image_paths: T.Sequence[Path],
-        xml_path: Path,
-        offset_time: float = 0.0,
-        num_processes: int | None = None,
-    ):
-        super().__init__(image_paths, num_processes=num_processes)
-        self.xml_path = xml_path
-        self.offset_time = offset_time
-
-    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]
-        )
-        video_paths = utils.find_videos(
-            [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)
-
-        video_metadata_or_errors = (
-            geotag_videos_from_exiftool_video.GeotagVideosFromExifToolVideo(
-                list(samples_by_video.keys()),
-                self.xml_path,
-                num_processes=self.num_processes,
-            ).to_description()
-        )
-        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()
-
-        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()
-        )
-
-        return sample_metadata_or_errors + non_sample_metadata_or_errors

mapillary_tools/geotag/geotag_videos_from_exiftool_video.py

@@ -1,151 +0,0 @@
-from __future__ import annotations
-
-import logging
-import typing as T
-import xml.etree.ElementTree as ET
-from pathlib import Path
-
-from .. import constants, exceptions, exiftool_read, geo, types, utils
-from ..exiftool_read_video import ExifToolReadVideo
-from ..exiftool_runner import ExiftoolRunner
-from ..gpmf import gpmf_gps_filter
-from ..telemetry import GPSPoint
-from .geotag_from_generic import GenericVideoExtractor, GeotagVideosFromGeneric
-
-LOG = logging.getLogger(__name__)
-
-
-class VideoExifToolExtractor(GenericVideoExtractor):
-    def __init__(self, video_path: Path, element: ET.Element):
-        super().__init__(video_path)
-        self.element = element
-
-    def extract(self) -> types.VideoMetadataOrError:
-        exif = ExifToolReadVideo(ET.ElementTree(self.element))
-
-        make = exif.extract_make()
-        model = exif.extract_model()
-
-        is_gopro = make is not None and make.upper() in ["GOPRO"]
-
-        points = exif.extract_gps_track()
-
-        # ExifTool has no idea if GPS is not found or found but empty
-        if is_gopro:
-            if not points:
-                raise exceptions.MapillaryGPXEmptyError("Empty GPS data found")
-
-            # ExifTool (since 13.04) converts GPSSpeed for GoPro to km/h, so here we convert it back to m/s
-            for p in points:
-                if isinstance(p, GPSPoint) and p.ground_speed is not None:
-                    p.ground_speed = p.ground_speed / 3.6
-
-            if isinstance(points[0], GPSPoint):
-                points = T.cast(
-                    T.List[geo.Point],
-                    gpmf_gps_filter.remove_noisy_points(
-                        T.cast(T.List[GPSPoint], points)
-                    ),
-                )
-                if not points:
-                    raise exceptions.MapillaryGPSNoiseError("GPS is too noisy")
-
-        if not points:
-            raise exceptions.MapillaryVideoGPSNotFoundError(
-                "No GPS data found from the video"
-            )
-
-        filetype = types.FileType.GOPRO if is_gopro else types.FileType.VIDEO
-
-        video_metadata = types.VideoMetadata(
-            self.video_path,
-            filesize=utils.get_file_size(self.video_path),
-            filetype=filetype,
-            points=points,
-            make=make,
-            model=model,
-        )
-
-        return video_metadata
-
-
-class GeotagVideosFromExifToolVideo(GeotagVideosFromGeneric):
-    def __init__(
-        self,
-        video_paths: T.Sequence[Path],
-        xml_path: Path,
-        num_processes: int | None = None,
-    ):
-        super().__init__(video_paths, num_processes=num_processes)
-        self.xml_path = xml_path
-
-    def _generate_video_extractors(
-        self,
-    ) -> T.Sequence[GenericVideoExtractor | types.ErrorMetadata]:
-        rdf_description_by_path = exiftool_read.index_rdf_description_by_path(
-            [self.xml_path]
-        )
-
-        results: list[VideoExifToolExtractor | types.ErrorMetadata] = []
-
-        for path in self.video_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 video not found"
-                )
-                results.append(
-                    types.describe_error_metadata(
-                        exc, path, filetype=types.FileType.VIDEO
-                    )
-                )
-            else:
-                results.append(VideoExifToolExtractor(path, rdf_description))
-
-        return results
-
-
-class GeotagVideosFromExifToolRunner(GeotagVideosFromGeneric):
-    def _generate_video_extractors(
-        self,
-    ) -> T.Sequence[GenericVideoExtractor | types.ErrorMetadata]:
-        runner = ExiftoolRunner(constants.EXIFTOOL_PATH)
-
-        LOG.debug(
-            "Extracting XML from %d videos with exiftool command: %s",
-            len(self.video_paths),
-            " ".join(runner._build_args_read_stdin()),
-        )
-
-        try:
-            xml = runner.extract_xml(self.video_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[VideoExifToolExtractor | types.ErrorMetadata] = []
-
-        for path in self.video_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 video not found"
-                )
-                results.append(
-                    types.describe_error_metadata(
-                        exc, path, filetype=types.FileType.VIDEO
-                    )
-                )
-            else:
-                results.append(VideoExifToolExtractor(path, rdf_description))
-
-        return results

mapillary_tools/video_data_extraction/cli_options.py

@@ -1,22 +0,0 @@
-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]