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

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

mapillary_tools-0.12.1.dist-info/RECORD

@@ -1,77 +0,0 @@
-mapillary_tools/__init__.py,sha256=Y_EQVeH08TULmSWJnga0Czi_46VOIkJR_BSsDzpxqNo,19
-mapillary_tools/api_v4.py,sha256=EX0x-mGjKJIM3KYHsrMo5ZcGVb1_1A2j01eP7gc17vo,1685
-mapillary_tools/authenticate.py,sha256=LCFcs6LqZmXaYkTUEKgGfmqytWdh5v_L3KXB48ojOZ4,3090
-mapillary_tools/config.py,sha256=jCjaK4jJaTY4AV4qf_b_tcxn5LA_uPsEWlGIdm2zw6g,2103
-mapillary_tools/constants.py,sha256=q5-4LG35aIrdUTaBh8v5WDGVR4o4fHYPCv0WFnKJLLg,2450
-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=BA4Mo0rdC-mM9jIAtFQbNJ2v4TkDqDiZzKfh5DcnwDE,14430
-mapillary_tools/ffmpeg.py,sha256=M56MrJSbwf5SJs15KwHZC8moxjx6SrB6gM0h-JMPq1U,15788
-mapillary_tools/geo.py,sha256=yAopdbA20R9RpG6hfyrXo6qP09Xpb915f8-BtYAgoiA,11211
-mapillary_tools/history.py,sha256=l2z3YdYRyBGEOvcqcLExTV-0LUAX3iBq2OdBzLNMHLM,1766
-mapillary_tools/ipc.py,sha256=DwWQb9hNshx0bg0Fo5NjY0mXjs-FkbR6tIQmjMgMtmg,1089
-mapillary_tools/process_geotag_properties.py,sha256=39gpT96Rzfu9hH1uGKDsYrFR8MLU1PNX_ytdlsL7yvI,22813
-mapillary_tools/process_import_meta_properties.py,sha256=pEqUp1pLzSNUoSEkxRGk1RVTtkE7FMagPo-yEagS3bk,2166
-mapillary_tools/process_sequence_properties.py,sha256=PLCSYJDNwr3rpUfh8kLNtUrUozYbRByR1g3xh3GCVCY,11559
-mapillary_tools/sample_video.py,sha256=3zji4zHt4hT_iWP0sV1XpNikFLfC-OGpk_p1NpSMPec,14385
-mapillary_tools/types.py,sha256=wNdb516UR039voIMN8_MtNPEyLWgzCb8dGj-nR74Pds,21490
-mapillary_tools/upload.py,sha256=Lm7juEYnMmpDLarTU-QGoxMvet1sS3eM3PqTE956LnY,29727
-mapillary_tools/upload_api_v4.py,sha256=-JlrPg5lCAo959jAbL8lYl72gTgQ3o-MawFuAQJ8Uj0,8596
-mapillary_tools/uploader.py,sha256=VieDKi51wdXTIhN7x_mcuQeHESUyFlF5cgB-TAnF4g0,14093
-mapillary_tools/utils.py,sha256=eg0TdJNjOJSYMB0NCxzOzDAbQc67NFOT919ZJxvSNRs,6257
-mapillary_tools/commands/__init__.py,sha256=wz89o8syKkWwoOCp3WBgnFWc41TBQRzRi62TlOTmVNQ,188
-mapillary_tools/commands/__main__.py,sha256=m9MRLyQJfgiki3eRBaagWUwNBKEbEiYtAaf2K3JsQmM,4940
-mapillary_tools/commands/authenticate.py,sha256=4aVvAQal_mqtm2NEMBt5aKLahi0iRdO8b7WSBf6jokA,1136
-mapillary_tools/commands/process.py,sha256=PyfIcpsS7vnLElr02ol1sQ_9Ma6J6uLusIuiyrAiF-c,12808
-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=GyLJ0wa2OO6fxr-8MoEelZsb2sOv3B2B2OhYtwFjzQc,2663
-mapillary_tools/commands/upload_blackvue.py,sha256=9RbCbz0-BquOIcp5JycnVbIAPUIqctwAm50LcLZw3N8,923
-mapillary_tools/commands/upload_camm.py,sha256=2zlBkZYbR2Hi4P02cHtBIymrqkudn5RrhFWwsCG7lG8,907
-mapillary_tools/commands/upload_zip.py,sha256=p8EZZktXLm8IipAbxrmz7E0RcfcLcxeGhEtxZzq5rSw,897
-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=1yrIs9Hp_-tNrClLQn2gxzCVWpkWTa6OlpLXgI4it70,2983
-mapillary_tools/geotag/camm_builder.py,sha256=AgY-LuuZy2w0Ni_GKI7Z_39Q19BfcghzfuHa5CSOK8o,8224
-mapillary_tools/geotag/camm_parser.py,sha256=zRQcPNgD_oibLp06aW_cwk4H3MvWqHDg-RiKVFiftTA,8830
-mapillary_tools/geotag/construct_mp4_parser.py,sha256=waaJl1wtQ2gbd6nIl9dj3V2nxiPYOn7bU8vopYeIWwE,16713
-mapillary_tools/geotag/geotag_from_generic.py,sha256=bCYfIbkv4qIlkKttAjSGl9t4i_QAtzIiCZoth1hMVI4,480
-mapillary_tools/geotag/geotag_images_from_exif.py,sha256=Wslwj3oNJdJjpSPV5JZ_aHEGF8O62LNQO7CBPczBOs0,4762
-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=GbNtPxE-FanzrPUI3FS-dadT5d0lyH_AcAAr4H6GL-o,3386
-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=5ezj-9uZszJiI9XZqW9b_XDYfX5RjlXnOyf7atCh47o,5143
-mapillary_tools/geotag/geotag_videos_from_video.py,sha256=HPVJqFeFDvvrFD0vfCimeaOyHHddcWlneAT0LjLUnZo,7098
-mapillary_tools/geotag/gpmf_gps_filter.py,sha256=7GHr05CLLF6lDGpMS3yAbZENh_vEfS0ezrfd_VFg3-c,2800
-mapillary_tools/geotag/gpmf_parser.py,sha256=GDV2yFhmsII4RdzbnPCQwd-Quk6NdMTJ0BcM0QH8ERU,15284
-mapillary_tools/geotag/gps_filter.py,sha256=4CPL8glxdzPWIbfGPPgyqMLyiZFt-djce5vhiFPuZB8,3766
-mapillary_tools/geotag/io_utils.py,sha256=wc3-F1TnxZjTwB7-oea5yRmRQ_0T3Zbz8oBkW9JL8d4,5454
-mapillary_tools/geotag/mp4_sample_parser.py,sha256=UxBqs0vFTA4qVth1ELkeBGElmW465_Vn2vKNApHmp7M,15141
-mapillary_tools/geotag/simple_mp4_builder.py,sha256=-0ZFe0rnFYNcRxxBLrrqytl5GPnKToUH8TPEYjZkjZs,11981
-mapillary_tools/geotag/simple_mp4_parser.py,sha256=eji6JZa497wK8CY8hQt21fjgtnd0nzuyBx7MPEKST74,6671
-mapillary_tools/geotag/utils.py,sha256=Orl35Df4ypxj4v6Lu1Mhk9d2XZxa8yNffz1s1C0JZsQ,651
-mapillary_tools/video_data_extraction/cli_options.py,sha256=g5kqzvkGJm6f5T4Vhum4JLL5qS6vE4iagQbEPtGJcug,563
-mapillary_tools/video_data_extraction/extract_video_data.py,sha256=2MJk4ekb3fhRLRThCrUsPOuTvHkPzyTTMTzlnfvuGD8,6603
-mapillary_tools/video_data_extraction/video_data_parser_factory.py,sha256=EDl4x_M0HvE4Pgwas679w70udLgeKuz6u-4Gv1BZQgE,1539
-mapillary_tools/video_data_extraction/extractors/base_parser.py,sha256=qNjS4LRDekD1E2Guqb2J5XstGVV9X2eN54CDlzXQGCw,1996
-mapillary_tools/video_data_extraction/extractors/blackvue_parser.py,sha256=zro4SUgqnVgEIrkjDf5yb6MJKOfl6ayPrr3FLoVBWO0,1143
-mapillary_tools/video_data_extraction/extractors/camm_parser.py,sha256=u7Yp7CYM0zdcRlpgkHQSB72x_uL2j-_AmwnGSREJPv0,1368
-mapillary_tools/video_data_extraction/extractors/exiftool_runtime_parser.py,sha256=mtdsoncnsspCtt5rMET2gxcEzvyOCyNv754RNhMEUNQ,2436
-mapillary_tools/video_data_extraction/extractors/exiftool_xml_parser.py,sha256=unLa5uZB1N5Vtl8bk19hayphRhXzHlSKgBYjVUv1hlQ,1848
-mapillary_tools/video_data_extraction/extractors/generic_video_parser.py,sha256=mw_byv66za_5Mb5TrWbD5UU2Ts6mAMZqLgKB9umWGsY,1955
-mapillary_tools/video_data_extraction/extractors/gopro_parser.py,sha256=xNXGuR7a-oDaE_WB2xK7sDpAGFwyWIsBUC8fSMKtfgM,1214
-mapillary_tools/video_data_extraction/extractors/gpx_parser.py,sha256=cqNGtlWFuuxBTf5BliCuJ14avxu-8Pz5LvXnTpTum60,815
-mapillary_tools/video_data_extraction/extractors/nmea_parser.py,sha256=QFMw_yf4uNP8z7tTybHMKHHMG6cS92bae-MJPHq6EJk,731
-mapillary_tools-0.12.1.dist-info/LICENSE,sha256=l2D8cKfFmmJq_wcVq_JElPJrlvWQOzNWx7gMLINucxc,1292
-mapillary_tools-0.12.1.dist-info/METADATA,sha256=nlA9PJrgEzB0LxKovlrER7YD-arXOyo7P6Zzr8PWt1Y,19638
-mapillary_tools-0.12.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-mapillary_tools-0.12.1.dist-info/entry_points.txt,sha256=A3f3LP-BO_P-U8Y29QfpT4jx6Mjk3sXjTi2Yew4bvj8,75
-mapillary_tools-0.12.1.dist-info/top_level.txt,sha256=FbDkMgOrt1S70ho1WSBrOwzKOSkJFDwwqFOoY5-527s,16
-mapillary_tools-0.12.1.dist-info/RECORD,,