mapillary-tools 0.13.3a1__py3-none-any.whl → 0.14.0__py3-none-any.whl

mapillary_tools/utils.py

@@ -1,14 +1,15 @@
+from __future__ import annotations
+
 import hashlib
 import os
 import typing as T
+from multiprocessing import Pool
 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:
@@ -90,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.
@@ -112,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:
@@ -121,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(
@@ -139,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(
@@ -157,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(
@@ -174,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
@@ -194,3 +195,33 @@ def find_xml_files(import_paths: T.Sequence[Path]) -> T.List[Path]:
 
 def get_file_size(path: Path) -> int:
     return os.path.getsize(path)
+
+
+def get_file_size_quietly(path: Path) -> int:
+    try:
+        return get_file_size(path)
+    except Exception:
+        return 0
+
+
+TMapIn = T.TypeVar("TMapIn")
+TMapOut = T.TypeVar("TMapOut")
+
+
+def mp_map_maybe(
+    func: T.Callable[[TMapIn], TMapOut],
+    iterable: T.Iterable[TMapIn],
+    num_processes: int | None = None,
+) -> T.Generator[TMapOut, None, None]:
+    if num_processes is None:
+        pool_num_processes = None
+        disable_multiprocessing = False
+    else:
+        pool_num_processes = max(num_processes, 1)
+        disable_multiprocessing = num_processes <= 0
+
+    if disable_multiprocessing:
+        yield from map(func, iterable)
+    else:
+        with Pool(processes=pool_num_processes) as pool:
+            yield from pool.imap(func, iterable)

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

@@ -1,31 +1,38 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: mapillary_tools
-Version: 0.13.3a1
+Version: 0.14.0
 Summary: Mapillary Image/Video Import Pipeline
-Home-page: https://github.com/mapillary/mapillary_tools
-Author: Mapillary
+Author-email: Mapillary <support@mapillary.com>
 License: BSD
-Requires-Python: >=3.8
+Project-URL: Homepage, https://github.com/mapillary/mapillary_tools
+Project-URL: Repository, https://github.com/mapillary/mapillary_tools
+Project-URL: Issues, https://github.com/mapillary/mapillary_tools/issues
+Keywords: mapillary,gis,computer vision,street view
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: appdirs<2.0.0,>=1.4.4
-Requires-Dist: construct<3.0.0,>=2.10.0
-Requires-Dist: exifread==2.3.2
-Requires-Dist: piexif==1.1.3
-Requires-Dist: gpxpy<1.6.0,>=1.5.0
+Requires-Dist: construct~=2.10.0
+Requires-Dist: exifread~=3.0
+Requires-Dist: gpxpy~=1.6.0
+Requires-Dist: humanize>=4.12.3
+Requires-Dist: jsonschema~=4.17.0
+Requires-Dist: piexif~=1.1
 Requires-Dist: pynmea2<2.0.0,>=1.12.0
 Requires-Dist: requests[socks]<3.0.0,>=2.20.0
 Requires-Dist: tqdm<5.0,>=4.0
-Requires-Dist: typing_extensions
-Requires-Dist: jsonschema~=4.17.3
-Dynamic: author
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
+Requires-Dist: typing-extensions>=4.12.2
+Dynamic: license-file
 
 <p align="center">
   <a href="https://github.com/mapillary/mapillary_tools/">
@@ -57,18 +64,40 @@ mapillary_tools --help
 <!--ts-->
 
 - [Supported File Formats](#supported-file-formats)
+  - [Image Formats](#image-formats)
+  - [Video Formats](#video-formats)
 - [Installation](#installation)
+  - [Standalone Executable](#standalone-executable)
+  - [Installing via pip](#installing-via-pip)
+    - [Installing on Android Devices](#installing-on-android-devices)
 - [Usage](#usage)
   - [Process and Upload](#process-and-upload)
   - [Process](#process)
   - [Upload](#upload)
 - [Advanced Usage](#advanced-usage)
   - [Local Video Processing](#local-video-processing)
+    - [Install FFmpeg](#install-ffmpeg)
+    - [Video Processing](#video-processing)
   - [Geotagging with GPX](#geotagging-with-gpx)
+  - [New video geotagging features (experimental)](#new-video-geotagging-features-experimental)
+    - [Usage](#usage-1)
+    - [Examples](#examples)
+      - [Generic supported videos](#generic-supported-videos)
+      - [External GPX](#external-gpx)
+      - [Insta360 stitched videos](#insta360-stitched-videos)
+    - [Limitations of `--video_geotag_source`](#limitations-of---video_geotag_source)
   - [Authenticate](#authenticate)
+    - [Examples](#examples-1)
   - [Image Description](#image-description)
   - [Zip Images](#zip-images)
 - [Development](#development)
+  - [Setup](#setup)
+    - [Option 1: Using uv (Recommended)](#option-1-using-uv-recommended)
+    - [Option 2: Using pip with virtual environment](#option-2-using-pip-with-virtual-environment)
+  - [Running the code](#running-the-code)
+  - [Tests](#tests)
+  - [Code Quality](#code-quality)
+  - [Release and Build](#release-and-build)
 
 <!--te-->
 
@@ -494,29 +523,49 @@ git clone git@github.com:mapillary/mapillary_tools.git
 cd mapillary_tools
 ```
 
-Set up the virtual environment. It is optional but recommended:
+### Option 1: Using uv (Recommended)
+
+Use [uv](https://docs.astral.sh/uv/) - a fast Python package manager.
+
+Install the project in development mode with all dependencies:
 
 ```sh
-pip install pipenv
+# Install the project and development dependencies
+uv sync --group dev
+
+# Activate the virtual environment
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
 ```
 
-Install dependencies:
+### Option 2: Using pip with virtual environment
+
+Set up a virtual environment (recommended):
 
 ```sh
-pipenv install -r requirements.txt
-pipenv install -r requirements-dev.txt
+python -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
 ```
 
-Enter the virtualenv shell:
+Install the project in development mode:
 
 ```sh
-pipenv shell
+# Install the project and all dependencies in editable mode
+pip install -e .
+
+# Install development dependencies
+pip install --group dev
 ```
 
+## Running the code
+
 Run the code from the repository:
 
 ```sh
-python3 -m mapillary_tools.commands --version
+# If you have mapillary_tools installed in editable mode
+mapillary_tools --version
+
+# Alternatively
+python -m mapillary_tools.commands --version
 ```
 
 ## Tests
@@ -524,19 +573,28 @@ python3 -m mapillary_tools.commands --version
 Run tests:
 
 ```sh
-# test all cases
-python3 -m pytest -s -vv tests
-# or test a single case specifically
-python3 -m pytest -s -vv tests/unit/test_camm_parser.py::test_build_and_parse
+# Test all cases
+pytest -s -vv tests
+# Or test a single case specifically
+pytest -s -vv tests/unit/test_camm_parser.py::test_build_and_parse
 ```
 
-Run linting:
+## Code Quality
+
+Run code formatting and linting:
 
 ```sh
-# format code
-black mapillary_tools tests
-# sort imports
+# Format code with ruff
+ruff format mapillary_tools tests
+
+# Lint code with ruff
+ruff check mapillary_tools tests
+
+# Sort imports with usort
 usort format mapillary_tools tests
+
+# Type checking with mypy
+mypy mapillary_tools
 ```
 
 ## Release and Build

mapillary_tools-0.14.0.dist-info/RECORD

@@ -0,0 +1,75 @@
+mapillary_tools/__init__.py,sha256=_3t9ZCm4vuKINk3jDtMZj_Wcw_4NcgFIpwhwW-DVWec,19
+mapillary_tools/api_v4.py,sha256=gDhFa2Jz6fGbPrtSrBjtPIXRXOxqWaXvcVCJT8KyRww,11788
+mapillary_tools/authenticate.py,sha256=OKS4jDFMo7XCzk9jEeHyZZUy-q56GoUZytJ5ta4QI8E,11219
+mapillary_tools/blackvue_parser.py,sha256=ea2JtU9MWU6yB0bQlF970_Of0bJVofSTRq1P30WKW-0,5623
+mapillary_tools/config.py,sha256=97zsyPnZXGincEkM__c6UNWH25EMTtRKZGsp6vBpHy8,3326
+mapillary_tools/constants.py,sha256=UuEuSajD3GvV73D5QRnjFlC6eDzQZbtQShaE2l98x18,6080
+mapillary_tools/exceptions.py,sha256=uxTgBEfXgGxT0XNGRIAZ5mjtdqsCYfP6gnaXAK_ewBM,2483
+mapillary_tools/exif_read.py,sha256=gagyRv06RkZPRHQhyV-5-uQzxHgxOsVqUX2aC8QmCyM,32145
+mapillary_tools/exif_write.py,sha256=I9GSs8KRd28QyKPVNHuxesSVbBvahHqKBS3nw9HoLsg,8830
+mapillary_tools/exiftool_read.py,sha256=5uatYE9mgbg2d9NAnPfX22nSRBjXhJ9ayMqNMd4QwGM,15779
+mapillary_tools/exiftool_read_video.py,sha256=23O_bjUOVq6j7i3xMz6fY-XIEsjinsCejK_0nrbFyOM,16084
+mapillary_tools/exiftool_runner.py,sha256=g4gSyqeh3D6EnMJ-c3s-RnO2EP_jD354Qkaz0Y-4D04,1658
+mapillary_tools/ffmpeg.py,sha256=akpvvsjAR-Iiv-hOrUoJvPM9vUU3JqMQ5HJL1_NgwB8,22908
+mapillary_tools/geo.py,sha256=mWaESfDf_zHmyvnt5aVFro4FGrjiULNsuZ6HfGUWvSA,11009
+mapillary_tools/history.py,sha256=LP6e0zEYVBwRGUbFaGoE_AaBIEdpB4XrZsg9qwJVvRI,5344
+mapillary_tools/ipc.py,sha256=DwWQb9hNshx0bg0Fo5NjY0mXjs-FkbR6tIQmjMgMtmg,1089
+mapillary_tools/process_geotag_properties.py,sha256=uT7dMpCujpBIysKd26sQRsIh8sVAkNv2DnzZQmEOmt0,14263
+mapillary_tools/process_sequence_properties.py,sha256=n4VjQHrgVjksIr3WoBviRhrQIBBDHGXMClolfyz6tu4,24057
+mapillary_tools/sample_video.py,sha256=gViQQ4CSHihzk42kGq_Rx4sr9sBPsGvPXXx2Bgj5grU,13980
+mapillary_tools/telemetry.py,sha256=lL6qQbtOZft4DZZrCNK3njlwHT_30zLyYS_YRN5pgHY,1568
+mapillary_tools/types.py,sha256=pIU2wcxiOUWT5Pd05pgNzY9EVEDlwoldtlF2IIYYvE0,5909
+mapillary_tools/upload.py,sha256=fOJ_cdPspVeGbqiATP4cLTcvR6tx3eIUlQxzADh863Q,23815
+mapillary_tools/upload_api_v4.py,sha256=ZpqWZ0WFiNCx3JUinLW7xKYkf4Tc-6oe3nE1qkXm898,7539
+mapillary_tools/uploader.py,sha256=lVauLejQd8cL7BdvR8z_i28t5-yxDVVEt_xlM43KUgs,32064
+mapillary_tools/utils.py,sha256=eqHVmaLDjEDYeLR-4b3gmg4_afoVi1RynVn8zQMFlt4,6773
+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=-tm3p90JMAIQ9o86_MRCA40_WffOYGacTGWxBNzzEVA,5026
+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=p2c_QGPJWrSaXyqjwC1Qh3yzV0Zy2V3wVIfTJx3cwYE,2819
+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/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapillary_tools/geotag/base.py,sha256=19-3P5nbFehOxacTT042nQUITzGnXndgnW_mXLO5q9s,4948
+mapillary_tools/geotag/factory.py,sha256=MuuLb9gcGWs7LHywyn8cGsml4eupdVQjji9jj_QCujk,10218
+mapillary_tools/geotag/geotag_images_from_exif.py,sha256=a5fDOp4tlEoVNwrOCJBrvSPzu1LbyxL4RNrNDD0tPP0,608
+mapillary_tools/geotag/geotag_images_from_exiftool.py,sha256=TTJb9tq1kYSPn_gwDDAcviueYwoUIbIEoLl-abAB8T8,5716
+mapillary_tools/geotag/geotag_images_from_gpx.py,sha256=EyhJjpP1L_DPRCX926aKeTvuxFxD-eWVCWgELp0-pzY,6313
+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=3NV3-NfSkxT0n_n8Ajqjab24x29H2vL98DpwJqnIvT8,4411
+mapillary_tools/geotag/geotag_videos_from_exiftool.py,sha256=ge29zKj9jLQFLmmzb0IyE69wenuwJ3XGmMyANT0UIAI,4288
+mapillary_tools/geotag/geotag_videos_from_gpx.py,sha256=IoV7asxl7dojF1lftvohm1jK_LboFg_mBz25GiV_CsY,1653
+mapillary_tools/geotag/geotag_videos_from_video.py,sha256=T8XS4lVF2Wz4eDXNi5Vt076M5dxjxJXibVrWhqVvErs,863
+mapillary_tools/geotag/options.py,sha256=0CSQUuhVE-WdAVQXWXjwMtxujW1yB6yxRkFmVKH8LkQ,5092
+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=KxyKxoh_mV-XBnJq3dSzNEt2rQqZAKjmS3GazsdYbnc,350
+mapillary_tools/geotag/video_extractors/exiftool.py,sha256=mH9arsWBaArYhNMxnrRpoEa3YrMjSpCiZaz-baJRMCo,2305
+mapillary_tools/geotag/video_extractors/gpx.py,sha256=jE3UQs6rTzIElPBvS7eKgR83JAZnbteXM1V5TbNCdyY,3753
+mapillary_tools/geotag/video_extractors/native.py,sha256=_xmTQ6nrvdwkadMmIxrhw6rvGTGwQVmrdSkYLhhV1SM,5786
+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=jS8fOgSByqieXA6C5ZqobaI0bK17U_YAkiWEUK_8j4E,17286
+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/serializer/description.py,sha256=FB-DawgHVW5M2e81Uo921bY7DQv9fogXF3QMilpmEhQ,18473
+mapillary_tools/serializer/gpx.py,sha256=_xx6gHjaWHrlXaUpB5GGBrbRKzbExFyIzWWAH-CvksI,4383
+mapillary_tools-0.14.0.dist-info/licenses/LICENSE,sha256=l2D8cKfFmmJq_wcVq_JElPJrlvWQOzNWx7gMLINucxc,1292
+mapillary_tools-0.14.0.dist-info/METADATA,sha256=QfSr8vy3dnl6HBeZjtYWgYoYpbJohbipNXmIio8lnO8,22200
+mapillary_tools-0.14.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mapillary_tools-0.14.0.dist-info/entry_points.txt,sha256=A3f3LP-BO_P-U8Y29QfpT4jx6Mjk3sXjTi2Yew4bvj8,75
+mapillary_tools-0.14.0.dist-info/top_level.txt,sha256=FbDkMgOrt1S70ho1WSBrOwzKOSkJFDwwqFOoY5-527s,16
+mapillary_tools-0.14.0.dist-info/RECORD,,

{mapillary_tools-0.13.3a1.dist-info → mapillary_tools-0.14.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

mapillary_tools/geotag/blackvue_parser.py

@@ -1,118 +0,0 @@
-import json
-import logging
-import pathlib
-import re
-import typing as T
-
-import pynmea2
-
-from .. import geo
-from ..mp4 import simple_mp4_parser as sparser
-
-
-LOG = logging.getLogger(__name__)
-# An example: [1623057074211]$GPVTG,,T,,M,0.078,N,0.144,K,D*28[1623057075215]
-NMEA_LINE_REGEX = re.compile(
-    rb"""
-    ^\s*
-    \[(\d+)\] # timestamp
-    \s*
-    (\$\w{5}.*) # nmea line
-    \s*
-    (\[\d+\])? # strange timestamp
-    \s*$
-    """,
-    re.X,
-)
-
-
-def _parse_gps_box(gps_data: bytes) -> T.Generator[geo.Point, None, None]:
-    for line_bytes in gps_data.splitlines():
-        match = NMEA_LINE_REGEX.match(line_bytes)
-        if match is None:
-            continue
-        nmea_line_bytes = match.group(2)
-        if nmea_line_bytes.startswith(b"$GPGGA"):
-            try:
-                nmea_line = nmea_line_bytes.decode("utf8")
-            except UnicodeDecodeError:
-                continue
-            try:
-                nmea = pynmea2.parse(nmea_line)
-            except pynmea2.nmea.ParseError:
-                continue
-            if not nmea.is_valid:
-                continue
-            epoch_ms = int(match.group(1))
-            yield geo.Point(
-                time=epoch_ms,
-                lat=nmea.latitude,
-                lon=nmea.longitude,
-                alt=nmea.altitude,
-                angle=None,
-            )
-
-
-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 ""
-
-    # examples: b' {"model":"DR900X Plus","ver":0.918,"lang":"English","direct":1,"psn":"","temp":34,"GPS":1}\x00'
-    #           b' Pittasoft Co., Ltd.;DR900S-1CH;1.008;English;1;D90SS1HAE00661;T69;\x00'
-    cprt_bytes = cprt_bytes.strip().strip(b"\x00")
-
-    try:
-        cprt_str = cprt_bytes.decode("utf8")
-    except UnicodeDecodeError:
-        return ""
-
-    try:
-        cprt_json = json.loads(cprt_str)
-    except json.JSONDecodeError:
-        cprt_json = None
-
-    if cprt_json is not None:
-        return str(cprt_json.get("model", "")).strip()
-
-    fields = cprt_str.split(";")
-    if 2 <= len(fields):
-        model = fields[1]
-        if model:
-            return model.strip()
-        else:
-            return ""
-    else:
-        return ""
-
-
-def extract_points(fp: T.BinaryIO) -> T.Optional[T.List[geo.Point]]:
-    gps_data = sparser.parse_mp4_data_first(fp, [b"free", b"gps "])
-    if gps_data is None:
-        return None
-
-    points = list(_parse_gps_box(gps_data))
-    if not points:
-        return points
-
-    points.sort(key=lambda p: p.time)
-
-    first_point_time = points[0].time
-    for p in points:
-        p.time = (p.time - first_point_time) / 1000
-
-    return points
-
-
-def parse_gps_points(path: pathlib.Path) -> T.List[geo.Point]:
-    with path.open("rb") as fp:
-        points = extract_points(fp)
-
-    if points is None:
-        return []
-
-    return points

mapillary_tools/geotag/geotag_from_generic.py

@@ -1,22 +0,0 @@
-import abc
-import typing as T
-
-from .. import types
-
-
-class GeotagImagesFromGeneric(abc.ABC):
-    def __init__(self) -> None:
-        pass
-
-    @abc.abstractmethod
-    def to_description(self) -> T.List[types.ImageMetadataOrError]:
-        raise NotImplementedError
-
-
-class GeotagVideosFromGeneric(abc.ABC):
-    def __init__(self) -> None:
-        pass
-
-    @abc.abstractmethod
-    def to_description(self) -> T.List[types.VideoMetadataOrError]:
-        raise NotImplementedError

mapillary_tools/geotag/geotag_images_from_exiftool_both_image_and_video.py

@@ -1,93 +0,0 @@
-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: T.Optional[int] = None,
-    ):
-        self.image_paths = image_paths
-        self.xml_path = xml_path
-        self.offset_time = offset_time
-        self.num_processes = num_processes
-        super().__init__()
-
-    def to_description(self) -> T.List[types.ImageMetadataOrError]:
-        # will return this list
-        final_image_metadatas: T.List[types.ImageMetadataOrError] = []
-
-        # find the images that can be geotagged from EXIF
-        image_metadatas_from_exiftool = (
-            geotag_images_from_exiftool.GeotagImagesFromExifTool(
-                self.image_paths,
-                self.xml_path,
-                num_processes=self.num_processes,
-            ).to_description()
-        )
-
-        # 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,
-        )
-
-        # will try to geotag these error metadatas from video later
-        error_metadata_by_image_path = {}
-        for image_metadata in image_metadatas_from_exiftool:
-            if isinstance(image_metadata, types.ErrorMetadata):
-                error_metadata_by_image_path[image_metadata.filename] = image_metadata
-            else:
-                final_image_metadatas.append(image_metadata)
-
-        maybe_image_samples = list(error_metadata_by_image_path.keys())
-
-        # find all video paths that have sample images
-        video_paths_with_image_samples = list(
-            utils.find_all_image_samples(maybe_image_samples, video_paths).keys()
-        )
-
-        video_metadatas = (
-            geotag_videos_from_exiftool_video.GeotagVideosFromExifToolVideo(
-                video_paths_with_image_samples,
-                self.xml_path,
-                num_processes=self.num_processes,
-            ).to_description()
-        )
-
-        image_metadatas_from_video = geotag_images_from_video.GeotagImagesFromVideo(
-            maybe_image_samples,
-            video_metadatas,
-            offset_time=self.offset_time,
-            num_processes=self.num_processes,
-        ).to_description()
-        final_image_metadatas.extend(image_metadatas_from_video)
-
-        # add back error metadatas that can not be geotagged at all
-        actual_image_sample_paths = set(
-            image_metadata.filename for image_metadata in image_metadatas_from_video
-        )
-        for path, error_metadata in error_metadata_by_image_path.items():
-            if path not in actual_image_sample_paths:
-                final_image_metadatas.append(error_metadata)
-
-        assert len(final_image_metadatas) <= len(self.image_paths)
-        return final_image_metadatas