mapillary-tools 0.12.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

mapillary_tools-0.13.0.dist-info/RECORD

@@ -0,0 +1,75 @@
+mapillary_tools/__init__.py,sha256=hZfMXyZ8nUrpqLa-dZCy9tXhu5fH1SZJKEGUd0caUDw,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
+mapillary_tools/constants.py,sha256=CZpKd9wUxlTC3lq7h3Mi5J1NpPlLYvgp1r0_sFUJKGk,2452
+mapillary_tools/exceptions.py,sha256=Mh1tgVEFTSMnYEzrl9x7b95fW9Z3SPVD_YMEl7r8I0I,2693
+mapillary_tools/exif_read.py,sha256=F60A0-T8XSBHvFKgVIrUz_ZWKQrTFWrtj3c6siB0IMg,28707
+mapillary_tools/exif_write.py,sha256=3PawLnBOY8Z86TYiA_F4LxRhe5Ui6CTNhxYm9yeJNX8,8786
+mapillary_tools/exiftool_read.py,sha256=Mg027me1IzblKb9IyGaLgU6goFqk_QiOt0Ppq-CeECg,16288
+mapillary_tools/exiftool_read_video.py,sha256=f3l8HiDjkrIhmslIXSsC8cNgkqCVWUFkN_0OQ5ZUd-U,14431
+mapillary_tools/ffmpeg.py,sha256=p1a5VxlbpLGLkzulMv51bpyD5omwK7Qg8277TGYmcZA,15780
+mapillary_tools/geo.py,sha256=QybCiQr0UDcH6DIDa2L6cZw4sDoTJNgR99oo6S7gCts,9746
+mapillary_tools/history.py,sha256=l2z3YdYRyBGEOvcqcLExTV-0LUAX3iBq2OdBzLNMHLM,1766
+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=WpBGPF_GMPjM_EFqXIutFtpDFL9wj7yEzGNGnfQZUo8,1255
+mapillary_tools/types.py,sha256=6kww2UdKM6YzabYbc862BYzEWtxL2hhxCRFfeDiUtF0,22074
+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=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
+mapillary_tools/commands/process.py,sha256=VxcvQpYHPw7QfT9dNwBLV1jWQ-1w4GtVNVPpmu4Sx9s,10578
+mapillary_tools/commands/process_and_upload.py,sha256=osJv1TVHYAG5E-EsA0nB1F3RkKXMadLR2t1EGK0Ifqw,654
+mapillary_tools/commands/sample_video.py,sha256=bTJmlDsajkC-QJ_ZO_scdD4R664zs-r_dh-x2PlOgyY,3281
+mapillary_tools/commands/upload.py,sha256=JIWgxupV3ppLvPi1iE7UVaE1302JGcIOvnuNt1Y7YEw,1671
+mapillary_tools/commands/video_process.py,sha256=-wQeeIwWXPmy81HQHam5A0huMLRHknkEFa_V1OwElU4,890
+mapillary_tools/commands/video_process_and_upload.py,sha256=llV0dHBS31qPZp-Fs1GCM0yYezEA_VF_tfYcp-Z8NkY,701
+mapillary_tools/commands/zip.py,sha256=DVQuMLpbstwiy5o4pU_fBvM6eORuFjLeySd80AhHKU0,991
+mapillary_tools/geotag/__init__.py,sha256=ohud7lLsqO1b9ddCF0SjrNOcUcRdQzNVR43RkcVVLAc,33
+mapillary_tools/geotag/blackvue_parser.py,sha256=_LTI_biiznFPvrk5dcpoDH4tP4_7khPIpW5Daumuf68,2968
+mapillary_tools/geotag/geotag_from_generic.py,sha256=bCYfIbkv4qIlkKttAjSGl9t4i_QAtzIiCZoth1hMVI4,480
+mapillary_tools/geotag/geotag_images_from_exif.py,sha256=hCgBwZABk2tbBQC3cHQBV5pvNwlAo8AkWSgCD0BU_QU,4823
+mapillary_tools/geotag/geotag_images_from_exiftool.py,sha256=a-c4H8VIyPdJkfUIvJho0phR0QU0zN8-lSyiCz0wc4s,3981
+mapillary_tools/geotag/geotag_images_from_exiftool_both_image_and_video.py,sha256=nRVAjgTJwx_eCaSBpPCgcIaZs3EYgGueYxSS9XhKv40,3350
+mapillary_tools/geotag/geotag_images_from_gpx.py,sha256=S9Pw6FvP5kRSpHUnKUYKXmw0CHa9V92UmrS_MJfbjS4,9053
+mapillary_tools/geotag/geotag_images_from_gpx_file.py,sha256=zEbC0kVf_iw9ioIyJLL-gYN_QvAOEdAoEczCBkizl38,5122
+mapillary_tools/geotag/geotag_images_from_nmea_file.py,sha256=dDdHnJInQ_WN3ZRf-w44NSBElDLPs7XYBiimvE2iCNo,1651
+mapillary_tools/geotag/geotag_images_from_video.py,sha256=XsaWOFChGItl-j1UbKM4hNjUqN29pVNbMpGT_BvI-o8,3306
+mapillary_tools/geotag/geotag_videos_from_exiftool_video.py,sha256=fkkWou1WFt3ft024399vis9No2cxrwot7Pg5HBw7o7s,5225
+mapillary_tools/geotag/geotag_videos_from_video.py,sha256=mqBZKUEkqT96nOzl5LJxzzTKuKsnAkMK5lH8k3oY3YE,7330
+mapillary_tools/geotag/gpmf_gps_filter.py,sha256=7cg8wEjC1DrujKY76FZguXsaPqTRkG9-t32OeuOJQIc,2755
+mapillary_tools/geotag/gpmf_parser.py,sha256=yAXzFAlj4VsbFju-kNDBxhT1K6kfmZL37lrM26Xkg0M,22514
+mapillary_tools/geotag/gps_filter.py,sha256=4CPL8glxdzPWIbfGPPgyqMLyiZFt-djce5vhiFPuZB8,3766
+mapillary_tools/geotag/utils.py,sha256=Orl35Df4ypxj4v6Lu1Mhk9d2XZxa8yNffz1s1C0JZsQ,651
+mapillary_tools/mp4/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapillary_tools/mp4/construct_mp4_parser.py,sha256=31oJbg6umKJjdZ0Ni5eCudC0lXd0Y-K_EiCCj6yW9js,17199
+mapillary_tools/mp4/io_utils.py,sha256=wc3-F1TnxZjTwB7-oea5yRmRQ_0T3Zbz8oBkW9JL8d4,5454
+mapillary_tools/mp4/mp4_sample_parser.py,sha256=YnTIIHGHL3ViLo_Ap0C2hk8MDWbWtvSXBLD42pRIWqY,11337
+mapillary_tools/mp4/simple_mp4_builder.py,sha256=7zVepmW-2SwoAeA-fvucmBW94jlcCFExDcEg8P3TOGY,12727
+mapillary_tools/mp4/simple_mp4_parser.py,sha256=eji6JZa497wK8CY8hQt21fjgtnd0nzuyBx7MPEKST74,6671
+mapillary_tools/video_data_extraction/cli_options.py,sha256=N0uHi9Uzaw1C8N-PE3yu8J3uEQP3HvSjJ9AZbIqoREg,535
+mapillary_tools/video_data_extraction/extract_video_data.py,sha256=_2BBdSYeYKR4BCHAZa1Jzo7OIK_va1lJDkTU2sXsPc0,6000
+mapillary_tools/video_data_extraction/video_data_parser_factory.py,sha256=qaJHvLgwI5lukJncMd8ggxeSxXOiVzBSJO5GlGQYiXY,1134
+mapillary_tools/video_data_extraction/extractors/base_parser.py,sha256=s7Xuwg4I5JZ27oL4ebMSdo093plAXfZ-6uDQ_h97WHY,2134
+mapillary_tools/video_data_extraction/extractors/blackvue_parser.py,sha256=jAcGyF6PML2EdJ4zle8cR12QeTRZc5qxlz8_4gcTZPU,1089
+mapillary_tools/video_data_extraction/extractors/camm_parser.py,sha256=sr8oDbC9lGyHHp8qkpQBmWOf4U_umlokaJM0kPVKgzw,1314
+mapillary_tools/video_data_extraction/extractors/exiftool_runtime_parser.py,sha256=PFNCRk9pGrPIfVwLMcnzmVNMITVjNHhbrOOMwxaSstg,2270
+mapillary_tools/video_data_extraction/extractors/exiftool_xml_parser.py,sha256=Tt0h4TiCKocERWMlRXzlpoaA_WJ_4b20MgMLGYNl4AM,1734
+mapillary_tools/video_data_extraction/extractors/generic_video_parser.py,sha256=34O6Km5kNDoJNJtIUOwtAzzMntuqkSZJfeli7caWSkA,1693
+mapillary_tools/video_data_extraction/extractors/gopro_parser.py,sha256=IVnTyquSraTUaG9rxbJfVWc1-drdY5PaHn5urh3IBk4,1325
+mapillary_tools/video_data_extraction/extractors/gpx_parser.py,sha256=FRysFhN2aa0MGnzLO7pcZkwo8790GUelIZg9pddZvic,2594
+mapillary_tools/video_data_extraction/extractors/nmea_parser.py,sha256=raSXavBvP-0LJCB_TwLL0mOv2uHSsB744igTsaKAaGc,658
+mapillary_tools-0.13.0.dist-info/LICENSE,sha256=l2D8cKfFmmJq_wcVq_JElPJrlvWQOzNWx7gMLINucxc,1292
+mapillary_tools-0.13.0.dist-info/METADATA,sha256=IjaJljFtCVqGSVhabQ2MptJlan76aUoGLulB1ecs9-E,19758
+mapillary_tools-0.13.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapillary_tools-0.13.0.dist-info/entry_points.txt,sha256=A3f3LP-BO_P-U8Y29QfpT4jx6Mjk3sXjTi2Yew4bvj8,75
+mapillary_tools-0.13.0.dist-info/top_level.txt,sha256=FbDkMgOrt1S70ho1WSBrOwzKOSkJFDwwqFOoY5-527s,16
+mapillary_tools-0.13.0.dist-info/RECORD,,

{mapillary_tools-0.12.0.dist-info → mapillary_tools-0.13.0.dist-info}/WHEEL

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

mapillary_tools/commands/upload_blackvue.py

@@ -1,33 +0,0 @@
-import inspect
-from pathlib import Path
-
-from .. import constants, upload
-from .upload import Command as UploadCommand
-
-
-class Command:
-    name = "upload_blackvue"
-    help = "[deprecated] upload BlackVue videos to Mapillary"
-
-    def add_basic_arguments(self, parser):
-        parser.add_argument(
-            "import_path",
-            help="Path to your BlackVue videos.",
-            nargs="+",
-            type=Path,
-        )
-        group = parser.add_argument_group(
-            f"{constants.ANSI_BOLD}UPLOAD OPTIONS{constants.ANSI_RESET_ALL}"
-        )
-        UploadCommand.add_common_upload_options(group)
-
-    def run(self, vars_args: dict):
-        args = {
-            k: v
-            for k, v in vars_args.items()
-            if k in inspect.getfullargspec(upload.upload).args
-        }
-        upload.upload(
-            **args,
-            filetypes={upload.DirectUploadFileType.RAW_BLACKVUE},
-        )

mapillary_tools/commands/upload_camm.py

@@ -1,33 +0,0 @@
-import inspect
-from pathlib import Path
-
-from .. import constants, upload
-from .upload import Command as UploadCommand
-
-
-class Command:
-    name = "upload_camm"
-    help = "[deprecated] upload CAMM videos to Mapillary"
-
-    def add_basic_arguments(self, parser):
-        parser.add_argument(
-            "import_path",
-            help="Path to your CAMM videos.",
-            nargs="+",
-            type=Path,
-        )
-        group = parser.add_argument_group(
-            f"{constants.ANSI_BOLD}UPLOAD OPTIONS{constants.ANSI_RESET_ALL}"
-        )
-        UploadCommand.add_common_upload_options(group)
-
-    def run(self, vars_args: dict):
-        args = {
-            k: v
-            for k, v in vars_args.items()
-            if k in inspect.getfullargspec(upload.upload).args
-        }
-        upload.upload(
-            **args,
-            filetypes={upload.DirectUploadFileType.RAW_CAMM},
-        )

mapillary_tools/commands/upload_zip.py

@@ -1,33 +0,0 @@
-import inspect
-from pathlib import Path
-
-from .. import constants, upload
-from .upload import Command as UploadCommand
-
-
-class Command:
-    name = "upload_zip"
-    help = "[deprecated] upload ZIP files to Mapillary"
-
-    def add_basic_arguments(self, parser):
-        parser.add_argument(
-            "import_path",
-            help="Path to your ZIP files.",
-            nargs="+",
-            type=Path,
-        )
-        group = parser.add_argument_group(
-            f"{constants.ANSI_BOLD}UPLOAD OPTIONS{constants.ANSI_RESET_ALL}"
-        )
-        UploadCommand.add_common_upload_options(group)
-
-    def run(self, vars_args: dict):
-        args = {
-            k: v
-            for k, v in vars_args.items()
-            if k in inspect.getfullargspec(upload.upload).args
-        }
-        upload.upload(
-            **args,
-            filetypes={upload.DirectUploadFileType.ZIP},
-        )

mapillary_tools/geotag/mp4_sample_parser.py

@@ -1,426 +0,0 @@
-import datetime
-import io
-import typing as T
-from pathlib import Path
-
-from . import construct_mp4_parser as cparser, simple_mp4_parser as parser
-
-
-class RawSample(T.NamedTuple):
-    # 1-based index
-    description_idx: int
-    # sample offset
-    offset: int
-    # sample size
-    size: int
-    # sample_delta read from stts entries,
-    # i.e. STTS(n) in the forumula DT(n+1) = DT(n) + STTS(n)
-    timedelta: int
-    # sample composition offset,
-    # i.e. CTTS(n) in the forumula CT(n) = DT(n) + CTTS(n).
-    composition_offset: int
-    # if it is a sync sample
-    is_sync: bool
-
-
-# TODO: can not inherit RawSample?
-class Sample(T.NamedTuple):
-    # copied from RawSample
-
-    # 1-based index
-    description_idx: int
-    # sample offset
-    offset: int
-    # sample size
-    size: int
-    # sample delta in seconds read from stts entries,
-    # i.e. (STTS(n) / timescale) in the forumula DT(n+1) = DT(n) + STTS(n)
-    timedelta: float
-    # sample composition offset in seconds,
-    # i.e. (CTTS(n) / timescale) in the forumula CT(n) = DT(n) + CTTS(n).
-    composition_offset: float
-    # if it is a sync sample
-    is_sync: bool
-
-    # extended fields below
-
-    # accumulated sample_delta in seconds,
-    # i.e. (DT(n) / timescale) in the forumula DT(n+1) = DT(n) + STTS(n)
-    time_offset: T.Union[int, float]
-    # accumulated composition offset in seconds,
-    # i.e. (CT(n) / timescale) in the forumula CT(n) = DT(n) + CTTS(n).
-    composition_time_offset: T.Union[int, float]
-    # reference to the sample description
-    description: T.Dict
-
-
-def _extract_raw_samples(
-    sizes: T.Sequence[int],
-    chunk_entries: T.Sequence[T.Dict],
-    chunk_offsets: T.Sequence[int],
-    timedeltas: T.Sequence[int],
-    composition_offsets: T.Optional[T.Sequence[int]],
-    syncs: T.Optional[T.Set[int]],
-) -> T.Generator[RawSample, None, None]:
-    if not sizes:
-        return
-
-    if not chunk_entries:
-        return
-
-    assert len(sizes) <= len(
-        timedeltas
-    ), f"got less ({len(timedeltas)}) sample time deltas (stts) than expected ({len(sizes)})"
-
-    sample_idx = 0
-    chunk_idx = 0
-
-    # iterate compressed chunks
-    for entry_idx, entry in enumerate(chunk_entries):
-        if entry_idx + 1 < len(chunk_entries):
-            nbr_chunks = (
-                chunk_entries[entry_idx + 1]["first_chunk"] - entry["first_chunk"]
-            )
-        else:
-            nbr_chunks = 1
-
-        # iterate chunks
-        for _ in range(nbr_chunks):
-            sample_offset = chunk_offsets[chunk_idx]
-            # iterate samples in this chunk
-            for _ in range(entry["samples_per_chunk"]):
-                is_sync = syncs is None or (sample_idx + 1) in syncs
-                composition_offset = (
-                    composition_offsets[sample_idx]
-                    if composition_offsets is not None
-                    else 0
-                )
-                yield RawSample(
-                    description_idx=entry["sample_description_index"],
-                    offset=sample_offset,
-                    size=sizes[sample_idx],
-                    timedelta=timedeltas[sample_idx],
-                    composition_offset=composition_offset,
-                    is_sync=is_sync,
-                )
-                sample_offset += sizes[sample_idx]
-                sample_idx += 1
-            chunk_idx += 1
-
-    # below handles the single-entry case:
-    # If all the chunks have the same number of samples per chunk
-    # and use the same sample description, this table has one entry.
-
-    # iterate chunks
-    while sample_idx < len(sizes):
-        sample_offset = chunk_offsets[chunk_idx]
-        # iterate samples in this chunk
-        for _ in range(chunk_entries[-1]["samples_per_chunk"]):
-            is_sync = syncs is None or (sample_idx + 1) in syncs
-            composition_offset = (
-                composition_offsets[sample_idx]
-                if composition_offsets is not None
-                else 0
-            )
-            yield RawSample(
-                description_idx=chunk_entries[-1]["sample_description_index"],
-                offset=sample_offset,
-                size=sizes[sample_idx],
-                timedelta=timedeltas[sample_idx],
-                composition_offset=composition_offset,
-                is_sync=is_sync,
-            )
-            sample_offset += sizes[sample_idx]
-            sample_idx += 1
-        chunk_idx += 1
-
-
-def _extract_samples(
-    raw_samples: T.Iterator[RawSample],
-    descriptions: T.List,
-) -> T.Generator[Sample, None, None]:
-    acc_delta = 0
-    for raw_sample in raw_samples:
-        yield Sample(
-            description_idx=raw_sample.description_idx,
-            offset=raw_sample.offset,
-            size=raw_sample.size,
-            timedelta=raw_sample.timedelta,
-            composition_offset=raw_sample.composition_offset,
-            is_sync=raw_sample.is_sync,
-            description=descriptions[raw_sample.description_idx - 1],
-            time_offset=acc_delta,
-            # CT(n) = DT(n) + CTTS(n)
-            composition_time_offset=(acc_delta + raw_sample.composition_offset),
-        )
-        acc_delta += raw_sample.timedelta
-
-
-def _apply_timescale(sample: Sample, media_timescale: int) -> Sample:
-    return Sample(
-        description_idx=sample.description_idx,
-        offset=sample.offset,
-        size=sample.size,
-        timedelta=sample.timedelta / media_timescale,
-        composition_offset=sample.composition_offset / media_timescale,
-        is_sync=sample.is_sync,
-        description=sample.description,
-        time_offset=sample.time_offset / media_timescale,
-        composition_time_offset=sample.composition_time_offset / media_timescale,
-    )
-
-
-def parse_raw_samples_from_stbl(
-    stbl: T.BinaryIO,
-    maxsize: int = -1,
-) -> T.Tuple[T.List[T.Dict], T.Generator[RawSample, None, None]]:
-    """
-    DEPRECATED: use parse_raw_samples_from_stbl_bytes instead
-    """
-
-    descriptions = []
-    sizes = []
-    chunk_offsets = []
-    chunk_entries = []
-    timedeltas: T.List[int] = []
-    composition_offsets: T.Optional[T.List[int]] = None
-    syncs: T.Optional[T.Set[int]] = None
-
-    for h, s in parser.parse_boxes(stbl, maxsize=maxsize, extend_eof=False):
-        if h.type == b"stsd":
-            box = cparser.SampleDescriptionBox.parse(s.read(h.maxsize))
-            descriptions = list(box.entries)
-        elif h.type == b"stsz":
-            box = cparser.SampleSizeBox.parse(s.read(h.maxsize))
-            if box.sample_size == 0:
-                sizes = list(box.entries)
-            else:
-                sizes = [box.sample_size for _ in range(box.sample_count)]
-        elif h.type == b"stco":
-            box = cparser.ChunkOffsetBox.parse(s.read(h.maxsize))
-            chunk_offsets = list(box.entries)
-        elif h.type == b"co64":
-            box = cparser.ChunkLargeOffsetBox.parse(s.read(h.maxsize))
-            chunk_offsets = list(box.entries)
-        elif h.type == b"stsc":
-            box = cparser.SampleToChunkBox.parse(s.read(h.maxsize))
-            chunk_entries = list(box.entries)
-        elif h.type == b"stts":
-            timedeltas = []
-            box = cparser.TimeToSampleBox.parse(s.read(h.maxsize))
-            for entry in box.entries:
-                for _ in range(entry.sample_count):
-                    timedeltas.append(entry.sample_delta)
-        elif h.type == b"ctts":
-            composition_offsets = []
-            box = cparser.CompositionTimeToSampleBox.parse(s.read(h.maxsize))
-            for entry in box.entries:
-                for _ in range(entry.sample_count):
-                    composition_offsets.append(entry.sample_offset)
-        elif h.type == b"stss":
-            box = cparser.SyncSampleBox.parse(s.read(h.maxsize))
-            syncs = set(box.entries)
-
-    # some stbl have less timedeltas than the sample count i.e. len(sizes),
-    # in this case append 0's to timedeltas
-    while len(timedeltas) < len(sizes):
-        timedeltas.append(0)
-    if composition_offsets is not None:
-        while len(composition_offsets) < len(sizes):
-            composition_offsets.append(0)
-
-    raw_samples = _extract_raw_samples(
-        sizes, chunk_entries, chunk_offsets, timedeltas, composition_offsets, syncs
-    )
-    return descriptions, raw_samples
-
-
-STBLBoxlistConstruct = cparser.Box64ConstructBuilder(
-    T.cast(cparser.SwitchMapType, cparser.CMAP[b"stbl"])
-).BoxList
-
-
-def parse_raw_samples_from_stbl_bytes(
-    stbl: bytes,
-) -> T.Tuple[T.List[T.Dict], T.Generator[RawSample, None, None]]:
-    descriptions = []
-    sizes = []
-    chunk_offsets = []
-    chunk_entries = []
-    timedeltas: T.List[int] = []
-    composition_offsets: T.Optional[T.List[int]] = None
-    syncs: T.Optional[T.Set[int]] = None
-
-    stbl_boxes = T.cast(T.Sequence[cparser.BoxDict], STBLBoxlistConstruct.parse(stbl))
-
-    for box in stbl_boxes:
-        data: T.Dict = T.cast(T.Dict, box["data"])
-
-        if box["type"] == b"stsd":
-            descriptions = list(data["entries"])
-        elif box["type"] == b"stsz":
-            if data["sample_size"] == 0:
-                sizes = list(data["entries"])
-            else:
-                sizes = [data["sample_size"] for _ in range(data["sample_count"])]
-        elif box["type"] == b"stco":
-            chunk_offsets = list(data["entries"])
-        elif box["type"] == b"co64":
-            chunk_offsets = list(data["entries"])
-        elif box["type"] == b"stsc":
-            chunk_entries = list(data["entries"])
-        elif box["type"] == b"stts":
-            timedeltas = []
-            for entry in data["entries"]:
-                for _ in range(entry["sample_count"]):
-                    timedeltas.append(entry["sample_delta"])
-        elif box["type"] == b"ctts":
-            composition_offsets = []
-            for entry in data["entries"]:
-                for _ in range(entry["sample_count"]):
-                    composition_offsets.append(entry["sample_offset"])
-        elif box["type"] == b"stss":
-            syncs = set(data["entries"])
-
-    # some stbl have less timedeltas than the sample count i.e. len(sizes),
-    # in this case append 0's to timedeltas
-    while len(timedeltas) < len(sizes):
-        timedeltas.append(0)
-    if composition_offsets is not None:
-        while len(composition_offsets) < len(sizes):
-            composition_offsets.append(0)
-
-    raw_samples = _extract_raw_samples(
-        sizes, chunk_entries, chunk_offsets, timedeltas, composition_offsets, syncs
-    )
-    return descriptions, raw_samples
-
-
-def parse_descriptions_from_trak(trak: T.BinaryIO, maxsize: int = -1) -> T.List[T.Dict]:
-    data = parser.parse_box_data_first(
-        trak, [b"mdia", b"minf", b"stbl", b"stsd"], maxsize=maxsize
-    )
-    if data is None:
-        return []
-    box = cparser.SampleDescriptionBox.parse(data)
-    return list(box.entries)
-
-
-def parse_samples_from_trak(
-    trak: T.BinaryIO,
-    maxsize: int = -1,
-) -> T.Generator[Sample, None, None]:
-    trak_start_offset = trak.tell()
-
-    trak.seek(trak_start_offset, io.SEEK_SET)
-    mdhd_box = parser.parse_box_data_firstx(trak, [b"mdia", b"mdhd"], maxsize=maxsize)
-    mdhd = T.cast(T.Dict, cparser.MediaHeaderBox.parse(mdhd_box))
-
-    trak.seek(trak_start_offset, io.SEEK_SET)
-    h, s = parser.parse_box_path_firstx(
-        trak, [b"mdia", b"minf", b"stbl"], maxsize=maxsize
-    )
-    descriptions, raw_samples = parse_raw_samples_from_stbl(s, maxsize=h.maxsize)
-
-    yield from (
-        _apply_timescale(s, mdhd["timescale"])
-        for s in _extract_samples(raw_samples, descriptions)
-    )
-
-
-STSDBoxListConstruct = cparser.Box64ConstructBuilder(
-    # pyre-ignore[6]: pyre does not support recursive type SwitchMapType
-    {b"stsd": cparser.CMAP[b"stsd"]}
-).BoxList
-
-
-class TrackBoxParser:
-    trak_boxes: T.Sequence[cparser.BoxDict]
-    stbl_data: bytes
-
-    def __init__(self, trak_boxes: T.Sequence[cparser.BoxDict]):
-        self.trak_boxes = trak_boxes
-        stbl = cparser.find_box_at_pathx(self.trak_boxes, [b"mdia", b"minf", b"stbl"])
-        self.stbl_data = T.cast(bytes, stbl["data"])
-
-    def tkhd(self) -> T.Dict:
-        return T.cast(
-            T.Dict, cparser.find_box_at_pathx(self.trak_boxes, [b"tkhd"])["data"]
-        )
-
-    def is_video_track(self) -> bool:
-        hdlr = cparser.find_box_at_pathx(self.trak_boxes, [b"mdia", b"hdlr"])
-        return T.cast(T.Dict[str, T.Any], hdlr["data"])["handler_type"] == b"vide"
-
-    def parse_sample_description(self) -> T.Dict:
-        boxes = STSDBoxListConstruct.parse(self.stbl_data)
-        stsd = cparser.find_box_at_pathx(
-            T.cast(T.Sequence[cparser.BoxDict], boxes), [b"stsd"]
-        )
-        return T.cast(T.Dict, stsd["data"])
-
-    def parse_raw_samples(self) -> T.Generator[RawSample, None, None]:
-        _, raw_samples = parse_raw_samples_from_stbl_bytes(self.stbl_data)
-        yield from raw_samples
-
-    def parse_samples(self) -> T.Generator[Sample, None, None]:
-        descriptions, raw_samples = parse_raw_samples_from_stbl_bytes(self.stbl_data)
-        mdhd = T.cast(
-            T.Dict,
-            cparser.find_box_at_pathx(self.trak_boxes, [b"mdia", b"mdhd"])["data"],
-        )
-        yield from (
-            _apply_timescale(s, mdhd["timescale"])
-            for s in _extract_samples(raw_samples, descriptions)
-        )
-
-
-class MovieBoxParser:
-    moov_boxes: T.Sequence[cparser.BoxDict]
-
-    def __init__(self, moov: bytes):
-        self.moov_boxes = T.cast(
-            T.Sequence[cparser.BoxDict],
-            cparser.MOOVWithoutSTBLBuilderConstruct.BoxList.parse(moov),
-        )
-
-    @classmethod
-    def parse_file(cls, video_path: Path) -> "MovieBoxParser":
-        with video_path.open("rb") as fp:
-            moov = parser.parse_box_data_firstx(fp, [b"moov"])
-        return MovieBoxParser(moov)
-
-    def mvhd(self):
-        mvhd = cparser.find_box_at_pathx(self.moov_boxes, [b"mvhd"])
-        return mvhd["data"]
-
-    def parse_tracks(self) -> T.Generator[TrackBoxParser, None, None]:
-        for box in self.moov_boxes:
-            if box["type"] == b"trak":
-                yield TrackBoxParser(T.cast(T.Sequence[cparser.BoxDict], box["data"]))
-
-    def parse_track_at(self, stream_idx: int) -> TrackBoxParser:
-        """
-        stream_idx should be the stream_index specifier. See http://ffmpeg.org/ffmpeg.html#Stream-specifiers-1
-        > Stream numbering is based on the order of the streams as detected by libavformat
-        """
-        trak_boxes = [box for box in self.moov_boxes if box["type"] == b"trak"]
-        if not (0 <= stream_idx < len(trak_boxes)):
-            raise IndexError(
-                "unable to read stream at %d from the track list (length %d)",
-                stream_idx,
-                len(trak_boxes),
-            )
-        return TrackBoxParser(
-            T.cast(T.Sequence[cparser.BoxDict], trak_boxes[stream_idx]["data"])
-        )
-
-
-_DT_1904 = datetime.datetime.utcfromtimestamp(0).replace(year=1904)
-
-
-def to_datetime(seconds_since_1904: int) -> datetime.datetime:
-    """
-    Convert seconds since midnight, Jan. 1, 1904, in UTC time
-    """
-    return _DT_1904 + datetime.timedelta(seconds=seconds_since_1904)

mapillary_tools/process_import_meta_properties.py

@@ -1,76 +0,0 @@
-import logging
-import typing as T
-
-from . import types
-
-
-LOG = logging.getLogger(__name__)
-
-
-def format_orientation(orientation: int) -> int:
-    """
-    Convert orientation from clockwise degrees to exif tag
-
-    # see http://sylvana.net/jpegcrop/exif_orientation.html
-    """
-    mapping: T.Mapping[int, int] = {
-        0: 1,
-        90: 8,
-        180: 3,
-        270: 6,
-    }
-    if orientation not in mapping:
-        raise ValueError("Orientation value has to be 0, 90, 180, or 270")
-
-    return mapping[orientation]
-
-
-def process_import_meta_properties(
-    metadatas: T.List[types.MetadataOrError],
-    orientation=None,
-    device_make=None,
-    device_model=None,
-    GPS_accuracy=None,
-    add_file_name=False,
-    add_import_date=False,
-    custom_meta_data=None,
-    camera_uuid=None,
-) -> T.List[types.MetadataOrError]:
-    if add_file_name:
-        LOG.warning("The option --add_file_name is not needed any more since v0.10.0")
-
-    if add_import_date:
-        LOG.warning("The option --add_import_date is not needed any more since v0.10.0")
-
-    if custom_meta_data:
-        LOG.warning(
-            "The option --custom_meta_data is not needed any more since v0.10.0"
-        )
-
-    for metadata in metadatas:
-        if isinstance(metadata, types.ErrorMetadata):
-            continue
-
-        if device_make is not None:
-            if isinstance(metadata, types.VideoMetadata):
-                metadata.make = device_make
-            else:
-                metadata.MAPDeviceMake = device_make
-
-        if device_model is not None:
-            if isinstance(metadata, types.VideoMetadata):
-                metadata.model = device_model
-            elif isinstance(metadata, types.ImageMetadata):
-                metadata.MAPDeviceModel = device_model
-
-        if isinstance(metadata, types.ImageMetadata):
-            if orientation is not None:
-                metadata.MAPOrientation = format_orientation(orientation)
-
-            if GPS_accuracy is not None:
-                metadata.MAPGPSAccuracyMeters = float(GPS_accuracy)
-
-            if camera_uuid is not None:
-                metadata.MAPCameraUUID = camera_uuid
-
-    return metadatas