mapillary-tools 0.12.1__tar.gz → 0.13.1__tar.gz

{mapillary_tools-0.12.1/mapillary_tools.egg-info → mapillary_tools-0.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: mapillary_tools
-Version: 0.12.1
+Version: 0.13.1
 Summary: Mapillary Image/Video Import Pipeline
 Home-page: https://github.com/mapillary/mapillary_tools
 Author: Mapillary
@@ -18,7 +18,14 @@ 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
-Requires-Dist: dataclasses; python_version <= "3.6"
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 <p align="center">
   <a href="https://github.com/mapillary/mapillary_tools/">

mapillary_tools-0.13.1/mapillary_tools/__init__.py

@@ -0,0 +1 @@
+VERSION = "0.13.1"

mapillary_tools-0.13.1/mapillary_tools/api_v4.py

@@ -0,0 +1,151 @@
+import logging
+import os
+import ssl
+import typing as T
+
+import requests
+from requests.adapters import HTTPAdapter
+
+LOG = logging.getLogger(__name__)
+MAPILLARY_CLIENT_TOKEN = os.getenv(
+    "MAPILLARY_CLIENT_TOKEN", "MLY|5675152195860640|6b02c72e6e3c801e5603ab0495623282"
+)
+MAPILLARY_GRAPH_API_ENDPOINT = os.getenv(
+    "MAPILLARY_GRAPH_API_ENDPOINT", "https://graph.mapillary.com"
+)
+REQUESTS_TIMEOUT = 60  # 1 minutes
+USE_SYSTEM_CERTS: bool = False
+
+
+class HTTPSystemCertsAdapter(HTTPAdapter):
+    """
+    This adapter uses the system's certificate store instead of the certifi module.
+
+    The implementation is based on the project https://pypi.org/project/pip-system-certs/,
+    which has a system-wide effect.
+    """
+
+    def init_poolmanager(self, *args, **kwargs):
+        ssl_context = ssl.create_default_context()
+        ssl_context.load_default_certs()
+        kwargs["ssl_context"] = ssl_context
+
+        super().init_poolmanager(*args, **kwargs)
+
+    def cert_verify(self, *args, **kwargs):
+        super().cert_verify(*args, **kwargs)
+
+        # By default Python requests uses the ca_certs from the certifi module
+        # But we want to use the certificate store instead.
+        # By clearing the ca_certs variable we force it to fall back on that behaviour (handled in urllib3)
+        if "conn" in kwargs:
+            conn = kwargs["conn"]
+        else:
+            conn = args[0]
+
+        conn.ca_certs = None
+
+
+def request_post(
+    url: str,
+    data: T.Optional[T.Any] = None,
+    json: T.Optional[dict] = None,
+    **kwargs,
+) -> requests.Response:
+    global USE_SYSTEM_CERTS
+
+    if USE_SYSTEM_CERTS:
+        with requests.Session() as session:
+            session.mount("https://", HTTPSystemCertsAdapter())
+            return session.post(url, data=data, json=json, **kwargs)
+
+    else:
+        try:
+            return requests.post(url, data=data, json=json, **kwargs)
+        except requests.exceptions.SSLError as ex:
+            if "SSLCertVerificationError" not in str(ex):
+                raise ex
+            USE_SYSTEM_CERTS = True
+            # HTTPSConnectionPool(host='graph.mapillary.com', port=443): Max retries exceeded with url: /login (Caused by SSLError(SSLCertVerificationError(1, '[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate (_ssl.c:1018)')))
+            LOG.warning(
+                "SSL error occurred, falling back to system SSL certificates: %s", ex
+            )
+            with requests.Session() as session:
+                session.mount("https://", HTTPSystemCertsAdapter())
+                return session.post(url, data=data, json=json, **kwargs)
+
+
+def request_get(
+    url: str,
+    params: T.Optional[dict] = None,
+    **kwargs,
+) -> requests.Response:
+    global USE_SYSTEM_CERTS
+
+    if USE_SYSTEM_CERTS:
+        with requests.Session() as session:
+            session.mount("https://", HTTPSystemCertsAdapter())
+            return session.get(url, params=params, **kwargs)
+    else:
+        try:
+            return requests.get(url, params=params, **kwargs)
+        except requests.exceptions.SSLError as ex:
+            if "SSLCertVerificationError" not in str(ex):
+                raise ex
+            USE_SYSTEM_CERTS = True
+            # HTTPSConnectionPool(host='graph.mapillary.com', port=443): Max retries exceeded with url: /login (Caused by SSLError(SSLCertVerificationError(1, '[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate (_ssl.c:1018)')))
+            LOG.warning(
+                "SSL error occurred, falling back to system SSL certificates: %s", ex
+            )
+            with requests.Session() as session:
+                session.mount("https://", HTTPSystemCertsAdapter())
+                return session.get(url, params=params, **kwargs)
+
+
+def get_upload_token(email: str, password: str) -> requests.Response:
+    resp = request_post(
+        f"{MAPILLARY_GRAPH_API_ENDPOINT}/login",
+        params={"access_token": MAPILLARY_CLIENT_TOKEN},
+        json={"email": email, "password": password, "locale": "en_US"},
+        timeout=REQUESTS_TIMEOUT,
+    )
+    resp.raise_for_status()
+    return resp
+
+
+def fetch_organization(
+    user_access_token: str, organization_id: T.Union[int, str]
+) -> requests.Response:
+    resp = request_get(
+        f"{MAPILLARY_GRAPH_API_ENDPOINT}/{organization_id}",
+        params={
+            "fields": ",".join(["slug", "description", "name"]),
+        },
+        headers={
+            "Authorization": f"OAuth {user_access_token}",
+        },
+        timeout=REQUESTS_TIMEOUT,
+    )
+    resp.raise_for_status()
+    return resp
+
+
+ActionType = T.Literal[
+    "upload_started_upload", "upload_finished_upload", "upload_failed_upload"
+]
+
+
+def log_event(action_type: ActionType, properties: T.Dict) -> requests.Response:
+    resp = request_post(
+        f"{MAPILLARY_GRAPH_API_ENDPOINT}/logging",
+        json={
+            "action_type": action_type,
+            "properties": properties,
+        },
+        headers={
+            "Authorization": f"OAuth {MAPILLARY_CLIENT_TOKEN}",
+        },
+        timeout=REQUESTS_TIMEOUT,
+    )
+    resp.raise_for_status()
+    return resp

{mapillary_tools-0.12.1/mapillary_tools/geotag → mapillary_tools-0.13.1/mapillary_tools/camm}/camm_builder.py

@@ -2,60 +2,46 @@ import io
 import typing as T
 
 from .. import geo, types
-
-from . import (
-    camm_parser,
+from ..mp4 import (
     construct_mp4_parser as cparser,
     mp4_sample_parser as sample_parser,
     simple_mp4_builder as builder,
 )
-from .simple_mp4_builder import BoxDict
 
+from . import camm_parser
 
-def build_camm_sample(point: geo.Point) -> bytes:
-    return camm_parser.CAMMSampleData.build(
-        {
-            "type": camm_parser.CAMMType.MIN_GPS.value,
-            "data": [
-                point.lat,
-                point.lon,
-                -1.0 if point.alt is None else point.alt,
-            ],
-        }
-    )
 
+def _build_camm_sample(measurement: camm_parser.TelemetryMeasurement) -> bytes:
+    for sample_entry_cls in camm_parser.SAMPLE_ENTRY_CLS_BY_CAMM_TYPE.values():
+        if sample_entry_cls.serializable(measurement):
+            return sample_entry_cls.serialize(measurement)
+    raise ValueError(f"Unsupported measurement type {type(measurement)}")
 
-def _create_edit_list(
+
+def _create_edit_list_from_points(
     point_segments: T.Sequence[T.Sequence[geo.Point]],
     movie_timescale: int,
     media_timescale: int,
-) -> BoxDict:
+) -> builder.BoxDict:
     entries: T.List[T.Dict] = []
 
-    for idx, points in enumerate(point_segments):
-        if not points:
-            entries = [
-                {
-                    "media_time": 0,
-                    "segment_duration": 0,
-                    "media_rate_integer": 1,
-                    "media_rate_fraction": 0,
-                }
-            ]
-            break
+    non_empty_point_segments = [points for points in point_segments if points]
 
-        assert (
-            0 <= points[0].time
-        ), f"expect non-negative point time but got {points[0]}"
-        assert (
-            points[0].time <= points[-1].time
-        ), f"expect points to be sorted but got first point {points[0]} and last point {points[-1]}"
+    for idx, points in enumerate(non_empty_point_segments):
+        assert 0 <= points[0].time, (
+            f"expect non-negative point time but got {points[0]}"
+        )
+        assert points[0].time <= points[-1].time, (
+            f"expect points to be sorted but got first point {points[0]} and last point {points[-1]}"
+        )
 
         if idx == 0:
             if 0 < points[0].time:
                 segment_duration = int(points[0].time * movie_timescale)
+                # put an empty edit list entry to skip the initial gap
                 entries.append(
                     {
+                        # If this field is set to –1, it is an empty edit
                         "media_time": -1,
                         "segment_duration": segment_duration,
                         "media_rate_integer": 1,
@@ -63,7 +49,6 @@ def _create_edit_list(
                     }
                 )
         else:
-            assert point_segments[-1][-1].time <= points[0].time
             media_time = int(points[0].time * media_timescale)
             segment_duration = int((points[-1].time - points[0].time) * movie_timescale)
             entries.append(
@@ -83,19 +68,34 @@ def _create_edit_list(
     }
 
 
-def convert_points_to_raw_samples(
-    points: T.Sequence[geo.Point], timescale: int
+def _multiplex(
+    points: T.Sequence[geo.Point],
+    measurements: T.Optional[T.List[camm_parser.TelemetryMeasurement]] = None,
+) -> T.List[camm_parser.TelemetryMeasurement]:
+    mutiplexed: T.List[camm_parser.TelemetryMeasurement] = [
+        *points,
+        *(measurements or []),
+    ]
+    mutiplexed.sort(key=lambda m: m.time)
+
+    return mutiplexed
+
+
+def convert_telemetry_to_raw_samples(
+    measurements: T.Sequence[camm_parser.TelemetryMeasurement],
+    timescale: int,
 ) -> T.Generator[sample_parser.RawSample, None, None]:
-    for idx, point in enumerate(points):
-        camm_sample_data = build_camm_sample(point)
+    for idx, measurement in enumerate(measurements):
+        camm_sample_data = _build_camm_sample(measurement)
 
-        if idx + 1 < len(points):
-            timedelta = int((points[idx + 1].time - point.time) * timescale)
+        if idx + 1 < len(measurements):
+            timedelta = int((measurements[idx + 1].time - measurement.time) * timescale)
         else:
             timedelta = 0
-        assert (
-            0 <= timedelta <= builder.UINT32_MAX
-        ), f"expected timedelta {timedelta} between {points[idx]} and {points[idx + 1]} with timescale {timescale} to be <= UINT32_MAX"
+
+        assert 0 <= timedelta <= builder.UINT32_MAX, (
+            f"expected timedelta {timedelta} between {measurements[idx]} and {measurements[idx + 1]} with timescale {timescale} to be <= UINT32_MAX"
+        )
 
         yield sample_parser.RawSample(
             # will update later
@@ -114,7 +114,9 @@ _STBLChildrenBuilderConstruct = cparser.Box32ConstructBuilder(
 )
 
 
-def _create_camm_stbl(raw_samples: T.Iterable[sample_parser.RawSample]) -> BoxDict:
+def _create_camm_stbl(
+    raw_samples: T.Iterable[sample_parser.RawSample],
+) -> builder.BoxDict:
     descriptions = [
         {
             "format": b"camm",
@@ -135,10 +137,10 @@ def _create_camm_stbl(raw_samples: T.Iterable[sample_parser.RawSample]) -> BoxDi
 def create_camm_trak(
     raw_samples: T.Sequence[sample_parser.RawSample],
     media_timescale: int,
-) -> BoxDict:
+) -> builder.BoxDict:
     stbl = _create_camm_stbl(raw_samples)
 
-    hdlr: BoxDict = {
+    hdlr: builder.BoxDict = {
         "type": b"hdlr",
         "data": {
             "handler_type": b"camm",
@@ -150,7 +152,7 @@ def create_camm_trak(
     assert media_timescale <= builder.UINT64_MAX
 
     # Media Header Box
-    mdhd: BoxDict = {
+    mdhd: builder.BoxDict = {
         "type": b"mdhd",
         "data": {
             # use 64-bit version
@@ -166,7 +168,7 @@ def create_camm_trak(
         },
     }
 
-    dinf: BoxDict = {
+    dinf: builder.BoxDict = {
         "type": b"dinf",
         "data": [
             # self reference dref box
@@ -187,7 +189,7 @@ def create_camm_trak(
         ],
     }
 
-    minf: BoxDict = {
+    minf: builder.BoxDict = {
         "type": b"minf",
         "data": [
             dinf,
@@ -195,7 +197,7 @@ def create_camm_trak(
         ],
     }
 
-    tkhd: BoxDict = {
+    tkhd: builder.BoxDict = {
         "type": b"tkhd",
         "data": {
             # use 32-bit version of the box
@@ -213,7 +215,7 @@ def create_camm_trak(
         },
     }
 
-    mdia: BoxDict = {
+    mdia: builder.BoxDict = {
         "type": b"mdia",
         "data": [
             mdhd,
@@ -231,23 +233,31 @@ def create_camm_trak(
     }
 
 
-def camm_sample_generator2(video_metadata: types.VideoMetadata):
+def camm_sample_generator2(
+    video_metadata: types.VideoMetadata,
+    telemetry_measurements: T.Optional[T.List[camm_parser.TelemetryMeasurement]] = None,
+):
     def _f(
         fp: T.BinaryIO,
-        moov_children: T.List[BoxDict],
+        moov_children: T.List[builder.BoxDict],
     ) -> T.Generator[io.IOBase, None, None]:
         movie_timescale = builder.find_movie_timescale(moov_children)
         # make sure the precision of timedeltas not lower than 0.001 (1ms)
         media_timescale = max(1000, movie_timescale)
+
+        # points with negative time are skipped
+        # TODO: interpolate first point at time == 0
+        # TODO: measurements with negative times should be skipped too
+        points = [point for point in video_metadata.points if point.time >= 0]
+
+        measurements = _multiplex(points, telemetry_measurements)
         camm_samples = list(
-            convert_points_to_raw_samples(video_metadata.points, media_timescale)
+            convert_telemetry_to_raw_samples(measurements, media_timescale)
         )
         camm_trak = create_camm_trak(camm_samples, media_timescale)
-        elst = _create_edit_list(
-            [video_metadata.points], movie_timescale, media_timescale
-        )
+        elst = _create_edit_list_from_points([points], movie_timescale, media_timescale)
         if T.cast(T.Dict, elst["data"])["entries"]:
-            T.cast(T.List[BoxDict], camm_trak["data"]).append(
+            T.cast(T.List[builder.BoxDict], camm_trak["data"]).append(
                 {
                     "type": b"edts",
                     "data": [elst],
@@ -255,7 +265,7 @@ def camm_sample_generator2(video_metadata: types.VideoMetadata):
             )
         moov_children.append(camm_trak)
 
-        udta_data: T.List[BoxDict] = []
+        udta_data: T.List[builder.BoxDict] = []
         if video_metadata.make:
             udta_data.append(
                 {
@@ -279,6 +289,8 @@ def camm_sample_generator2(video_metadata: types.VideoMetadata):
             )
 
         # if yield, the moov_children will not be modified
-        return (io.BytesIO(build_camm_sample(point)) for point in video_metadata.points)
+        return (
+            io.BytesIO(_build_camm_sample(measurement)) for measurement in measurements
+        )
 
     return _f