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

mapillary_tools/video_data_extraction/extractors/base_parser.py

@@ -1,75 +0,0 @@
-import abc
-import functools
-import logging
-import os
-import typing as T
-from pathlib import Path
-
-from ... import geo
-from ..cli_options import CliOptions, CliParserOptions
-
-LOG = logging.getLogger(__name__)
-
-
-class BaseParser(metaclass=abc.ABCMeta):
-    videoPath: Path
-    options: CliOptions
-    parserOptions: CliParserOptions
-
-    def __init__(
-        self, video_path: Path, options: CliOptions, parser_options: CliParserOptions
-    ) -> None:
-        self.videoPath = video_path
-        self.options = options
-        self.parserOptions = parser_options
-
-    @property
-    @abc.abstractmethod
-    def default_source_pattern(self) -> str:
-        raise NotImplementedError
-
-    @property
-    @abc.abstractmethod
-    def parser_label(self) -> str:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def extract_points(self) -> T.Sequence[geo.Point]:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def extract_make(self) -> T.Optional[str]:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def extract_model(self) -> T.Optional[str]:
-        raise NotImplementedError
-
-    @functools.cached_property
-    def geotag_source_path(self) -> T.Optional[Path]:
-        video_dir = self.videoPath.parent.resolve()
-        video_filename = self.videoPath.name
-        video_basename, video_ext = os.path.splitext(video_filename)
-        pattern = self.parserOptions.get("pattern") or self.default_source_pattern
-
-        replaced = Path(
-            pattern.replace("%f", video_filename)
-            .replace("%g", video_basename)
-            .replace("%e", video_ext)
-        )
-        abs_path = (
-            replaced if replaced.is_absolute() else Path.joinpath(video_dir, replaced)
-        ).resolve()
-
-        return abs_path if abs_path.is_file() else None
-
-    @staticmethod
-    def _rebase_times(points: T.Sequence[geo.Point], offset: float = 0.0):
-        """
-        Make point times start from 0
-        """
-        if points:
-            first_timestamp = points[0].time
-            for p in points:
-                p.time = (p.time - first_timestamp) + offset
-        return points

mapillary_tools/video_data_extraction/extractors/blackvue_parser.py

@@ -1,34 +0,0 @@
-import typing as T
-
-from ... import geo
-from ...geotag import blackvue_parser
-from ...mp4 import simple_mp4_parser as sparser
-from .base_parser import BaseParser
-
-
-class BlackVueParser(BaseParser):
-    default_source_pattern = "%f"
-    must_rebase_times_to_zero = False
-    parser_label = "blackvue"
-
-    pointsFound: bool = False
-
-    def extract_points(self) -> T.Sequence[geo.Point]:
-        source_path = self.geotag_source_path
-        if not source_path:
-            return []
-        with source_path.open("rb") as fp:
-            try:
-                points = blackvue_parser.extract_points(fp) or []
-                self.pointsFound = len(points) > 0
-                return points
-            except sparser.ParsingError:
-                return []
-
-    def extract_make(self) -> T.Optional[str]:
-        # If no points were found, assume this is not a BlackVue
-        return "Blackvue" if self.pointsFound else None
-
-    def extract_model(self) -> T.Optional[str]:
-        with self.videoPath.open("rb") as fp:
-            return blackvue_parser.extract_camera_model(fp) or None

mapillary_tools/video_data_extraction/extractors/camm_parser.py

@@ -1,38 +0,0 @@
-import functools
-import typing as T
-
-from ... import geo
-from ...camm import camm_parser
-from ...mp4 import simple_mp4_parser as sparser
-from .base_parser import BaseParser
-
-
-class CammParser(BaseParser):
-    default_source_pattern = "%f"
-    must_rebase_times_to_zero = False
-    parser_label = "camm"
-
-    @functools.cached_property
-    def _camera_info(self) -> T.Tuple[str, str]:
-        source_path = self.geotag_source_path
-        if not source_path:
-            return "", ""
-
-        with source_path.open("rb") as fp:
-            return camm_parser.extract_camera_make_and_model(fp)
-
-    def extract_points(self) -> T.Sequence[geo.Point]:
-        source_path = self.geotag_source_path
-        if not source_path:
-            return []
-        with source_path.open("rb") as fp:
-            try:
-                return camm_parser.extract_points(fp) or []
-            except sparser.ParsingError:
-                return []
-
-    def extract_make(self) -> T.Optional[str]:
-        return self._camera_info[0] or None
-
-    def extract_model(self) -> T.Optional[str]:
-        return self._camera_info[1] or None

mapillary_tools/video_data_extraction/extractors/exiftool_runtime_parser.py

@@ -1,71 +0,0 @@
-import shutil
-import subprocess
-import typing as T
-from pathlib import Path
-
-from ... import constants, exceptions, geo
-from ..cli_options import CliOptions, CliParserOptions
-from .base_parser import BaseParser
-from .exiftool_xml_parser import ExiftoolXmlParser
-
-
-class ExiftoolRuntimeParser(BaseParser):
-    """
-    Wrapper around ExiftoolRdfParser that executes exiftool
-    """
-
-    exiftoolXmlParser: ExiftoolXmlParser
-
-    default_source_pattern = "%f"
-    must_rebase_times_to_zero = True
-    parser_label = "exiftool_runtime"
-
-    def __init__(
-        self, video_path: Path, options: CliOptions, parser_options: CliParserOptions
-    ):
-        super().__init__(video_path, options, parser_options)
-        exiftool_path = shutil.which(constants.EXIFTOOL_PATH)
-
-        if not exiftool_path:
-            raise exceptions.MapillaryExiftoolNotFoundError(
-                "Cannot execute exiftool. Please install it from https://exiftool.org/ or you package manager, or set the environment variable MAPILLARY_TOOLS_EXIFTOOL_PATH"
-            )
-        if not self.geotag_source_path:
-            return
-
-        # To handle non-latin1 filenames under Windows, we pass the path
-        # via stdin. See https://exiftool.org/faq.html#Q18
-        stdin = str(self.geotag_source_path)
-        args = [
-            exiftool_path,
-            "-q",
-            "-r",
-            "-n",
-            "-ee",
-            "-api",
-            "LargeFileSupport=1",
-            "-X",
-            "-charset",
-            "filename=utf8",
-            "-@",
-            "-",
-        ]
-
-        process = subprocess.run(
-            args, capture_output=True, text=True, input=stdin, encoding="utf-8"
-        )
-
-        self.exiftoolXmlParser = ExiftoolXmlParser(
-            video_path, options, parser_options, process.stdout
-        )
-
-    def extract_points(self) -> T.Sequence[geo.Point]:
-        return self.exiftoolXmlParser.extract_points() if self.exiftoolXmlParser else []
-
-    def extract_make(self) -> T.Optional[str]:
-        return self.exiftoolXmlParser.extract_make() if self.exiftoolXmlParser else None
-
-    def extract_model(self) -> T.Optional[str]:
-        return (
-            self.exiftoolXmlParser.extract_model() if self.exiftoolXmlParser else None
-        )

mapillary_tools/video_data_extraction/extractors/exiftool_xml_parser.py

@@ -1,53 +0,0 @@
-import typing as T
-import xml.etree.ElementTree as ET
-
-from pathlib import Path
-
-from ... import geo
-from ...exiftool_read import EXIFTOOL_NAMESPACES
-from ...exiftool_read_video import ExifToolReadVideo
-from ...geotag.geotag_videos_from_exiftool_video import _DESCRIPTION_TAG
-from ..cli_options import CliOptions, CliParserOptions
-from .base_parser import BaseParser
-
-
-class ExiftoolXmlParser(BaseParser):
-    default_source_pattern = "%g.xml"
-    parser_label = "exiftool_xml"
-
-    exifToolReadVideo: T.Optional[ExifToolReadVideo] = None
-
-    def __init__(
-        self,
-        video_path: Path,
-        options: CliOptions,
-        parser_options: CliParserOptions,
-        xml_content: T.Optional[str] = None,
-    ) -> None:
-        super().__init__(video_path, options, parser_options)
-
-        if xml_content:
-            etree = ET.fromstring(xml_content)
-        else:
-            xml_path = self.geotag_source_path
-            if not xml_path:
-                return
-            etree = ET.parse(xml_path).getroot()
-
-        element = next(etree.iterfind(_DESCRIPTION_TAG, namespaces=EXIFTOOL_NAMESPACES))
-        self.exifToolReadVideo = ExifToolReadVideo(ET.ElementTree(element))
-
-    def extract_points(self) -> T.Sequence[geo.Point]:
-        gps_points = (
-            self.exifToolReadVideo.extract_gps_track() if self.exifToolReadVideo else []
-        )
-        self._rebase_times(gps_points)
-        return gps_points
-
-    def extract_make(self) -> T.Optional[str]:
-        return self.exifToolReadVideo.extract_make() if self.exifToolReadVideo else None
-
-    def extract_model(self) -> T.Optional[str]:
-        return (
-            self.exifToolReadVideo.extract_model() if self.exifToolReadVideo else None
-        )

mapillary_tools/video_data_extraction/extractors/generic_video_parser.py

@@ -1,52 +0,0 @@
-import typing as T
-from pathlib import Path
-
-from ... import geo
-from ..cli_options import CliOptions, CliParserOptions
-from .base_parser import BaseParser
-from .blackvue_parser import BlackVueParser
-from .camm_parser import CammParser
-from .gopro_parser import GoProParser
-
-
-class GenericVideoParser(BaseParser):
-    """
-    Wrapper around the three native video parsers. It will try to execute them
-    in the order camm-gopro-blackvue, like the previous implementation
-    """
-
-    parsers: T.Sequence[BaseParser] = []
-
-    default_source_pattern = "%f"
-    must_rebase_times_to_zero = False
-    parser_label = "video"
-
-    def __init__(
-        self, video_path: Path, options: CliOptions, parser_options: CliParserOptions
-    ) -> None:
-        super().__init__(video_path, options, parser_options)
-        camm_parser = CammParser(video_path, options, parser_options)
-        gopro_parser = GoProParser(video_path, options, parser_options)
-        blackvue_parser = BlackVueParser(video_path, options, parser_options)
-        self.parsers = [camm_parser, gopro_parser, blackvue_parser]
-
-    def extract_points(self) -> T.Sequence[geo.Point]:
-        for parser in self.parsers:
-            points = parser.extract_points()
-            if points:
-                return points
-        return []
-
-    def extract_make(self) -> T.Optional[str]:
-        for parser in self.parsers:
-            make = parser.extract_make()
-            if make:
-                return make
-        return None
-
-    def extract_model(self) -> T.Optional[str]:
-        for parser in self.parsers:
-            model = parser.extract_model()
-            if model:
-                return model
-        return None

mapillary_tools/video_data_extraction/extractors/gopro_parser.py

@@ -1,43 +0,0 @@
-import typing as T
-
-from ... import geo
-from ...geotag import gpmf_parser
-from ...mp4 import simple_mp4_parser as sparser
-from .base_parser import BaseParser
-
-
-class GoProParser(BaseParser):
-    default_source_pattern = "%f"
-    must_rebase_times_to_zero = False
-    parser_label = "gopro"
-
-    pointsFound: bool = False
-
-    def extract_points(self) -> T.Sequence[geo.Point]:
-        source_path = self.geotag_source_path
-        if not source_path:
-            return []
-        with source_path.open("rb") as fp:
-            try:
-                points = gpmf_parser.extract_points(fp) or []
-                self.pointsFound = len(points) > 0
-                return points
-            except sparser.ParsingError:
-                return []
-
-    def extract_make(self) -> T.Optional[str]:
-        model = self.extract_model()
-        if model:
-            return "GoPro"
-
-        # make sure self.pointsFound is updated
-        _ = self.extract_points()
-        # If no points were found, assume this is not a GoPro
-        return "GoPro" if self.pointsFound else None
-
-    def extract_model(self) -> T.Optional[str]:
-        source_path = self.geotag_source_path
-        if not source_path:
-            return None
-        with source_path.open("rb") as fp:
-            return gpmf_parser.extract_camera_model(fp) or None

mapillary_tools/video_data_extraction/extractors/nmea_parser.py

@@ -1,24 +0,0 @@
-import typing as T
-
-from ... import geo
-from ...geotag import geotag_images_from_nmea_file
-from .base_parser import BaseParser
-
-
-class NmeaParser(BaseParser):
-    default_source_pattern = "%g.nmea"
-    must_rebase_times_to_zero = True
-    parser_label = "nmea"
-
-    def extract_points(self) -> T.Sequence[geo.Point]:
-        source_path = self.geotag_source_path
-        if not source_path:
-            return []
-        points = geotag_images_from_nmea_file.get_lat_lon_time_from_nmea(source_path)
-        return points
-
-    def extract_make(self) -> T.Optional[str]:
-        return None
-
-    def extract_model(self) -> T.Optional[str]:
-        return None

mapillary_tools/video_data_extraction/video_data_parser_factory.py

@@ -1,39 +0,0 @@
-import typing as T
-from pathlib import Path
-
-from .cli_options import CliOptions
-
-from .extractors.base_parser import BaseParser
-
-from .extractors.blackvue_parser import BlackVueParser
-from .extractors.camm_parser import CammParser
-
-from .extractors.exiftool_runtime_parser import ExiftoolRuntimeParser
-from .extractors.exiftool_xml_parser import ExiftoolXmlParser
-from .extractors.generic_video_parser import GenericVideoParser
-from .extractors.gopro_parser import GoProParser
-from .extractors.gpx_parser import GpxParser
-from .extractors.nmea_parser import NmeaParser
-
-
-known_parsers = {
-    "gpx": GpxParser,
-    "nmea": NmeaParser,
-    "exiftool_xml": ExiftoolXmlParser,
-    "exiftool_runtime": ExiftoolRuntimeParser,
-    "camm": CammParser,
-    "blackvue": BlackVueParser,
-    "gopro": GoProParser,
-    "video": GenericVideoParser,
-}
-
-
-def make_parsers(file: Path, options: CliOptions) -> T.Sequence[BaseParser]:
-    src_options = options["geotag_sources_options"]
-    parsers = [
-        known_parsers[s["source"]](file, options, s)
-        for s in src_options
-        if s["source"] in known_parsers
-    ]
-
-    return parsers

mapillary_tools-0.13.3a1.dist-info/RECORD

@@ -1,75 +0,0 @@
-mapillary_tools/__init__.py,sha256=j5y1cIo14OOuS27ROUABVHN9119rEXV-bdoM-z117o8,21
-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=KKQMwzpN2z7wka6lhZv-agdxNldaEQqvQXu3Kg5XuUk,2453
-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=VXIAA_lar4y4RgvNuKpkE7CVl4uWa6kNT59hCVFClSk,8490
-mapillary_tools/uploader.py,sha256=DBHso4QIP5nsZFDynLjkUvytzwpEOPnOlfeDyA6rTBk,14007
-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=-vTbZ1HufZzJCd8VvukdTjsJRcymtfld2W5t65VSG5E,5300
-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=6Q38oeSd2kHTs44Fzpg9R555EbQqdd5QcIuIZdG4z_o,23233
-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=YMiViocXSVlfn8_qm1jcwSJhnnEaK8v5ADHwo2YXe10,1117
-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=FNrdnXl48k8I1I5fGwYsClhfFEHVsooRLRboUYECv3I,3811
-mapillary_tools/video_data_extraction/extractors/nmea_parser.py,sha256=raSXavBvP-0LJCB_TwLL0mOv2uHSsB744igTsaKAaGc,658
-mapillary_tools-0.13.3a1.dist-info/LICENSE,sha256=l2D8cKfFmmJq_wcVq_JElPJrlvWQOzNWx7gMLINucxc,1292
-mapillary_tools-0.13.3a1.dist-info/METADATA,sha256=3wyt_Iv96Md1JNY358MhdTqO02bb0XKdEoDBMiP3_yw,19760
-mapillary_tools-0.13.3a1.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-mapillary_tools-0.13.3a1.dist-info/entry_points.txt,sha256=A3f3LP-BO_P-U8Y29QfpT4jx6Mjk3sXjTi2Yew4bvj8,75
-mapillary_tools-0.13.3a1.dist-info/top_level.txt,sha256=FbDkMgOrt1S70ho1WSBrOwzKOSkJFDwwqFOoY5-527s,16
-mapillary_tools-0.13.3a1.dist-info/RECORD,,