mapillary-tools 0.14.0__tar.gz → 0.14.4__tar.gz

{mapillary_tools-0.14.0 → mapillary_tools-0.14.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapillary_tools
-Version: 0.14.0
+Version: 0.14.4
 Summary: Mapillary Image/Video Import Pipeline
 Author-email: Mapillary <support@mapillary.com>
 License: BSD

mapillary_tools-0.14.4/mapillary_tools/__init__.py

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

mapillary_tools-0.14.4/mapillary_tools/api_v4.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import enum
+import logging
+import os
+import typing as T
+
+import requests
+
+from . import http
+
+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: float = 60  # 1 minutes
+
+
+class HTTPContentError(Exception):
+    """
+    Raised when the HTTP response is ok (200) but the content is not as expected
+    e.g. not JSON or not a valid response.
+    """
+
+    def __init__(self, message: str, response: requests.Response):
+        self.response = response
+        super().__init__(message)
+
+
+class ClusterFileType(enum.Enum):
+    ZIP = "zip"
+    BLACKVUE = "mly_blackvue_video"
+    CAMM = "mly_camm_video"
+    MLY_BUNDLE_MANIFEST = "mly_bundle_manifest"
+
+
+def create_user_session(user_access_token: str) -> requests.Session:
+    session = http.Session()
+    session.headers["Authorization"] = f"OAuth {user_access_token}"
+    return session
+
+
+def create_client_session(disable_logging: bool = False) -> requests.Session:
+    session = http.Session()
+    session.headers["Authorization"] = f"OAuth {MAPILLARY_CLIENT_TOKEN}"
+    if disable_logging:
+        session.disable_logging_request = True
+        session.disable_logging_response = True
+    return session
+
+
+def is_auth_error(resp: requests.Response) -> bool:
+    if resp.status_code in [401, 403]:
+        return True
+
+    if resp.status_code in [400]:
+        try:
+            error_body = resp.json()
+        except Exception:
+            error_body = {}
+
+        type = error_body.get("debug_info", {}).get("type")
+        if type in ["NotAuthorizedError"]:
+            return True
+
+    return False
+
+
+def extract_auth_error_message(resp: requests.Response) -> str:
+    assert is_auth_error(resp), "has to be an auth error"
+
+    try:
+        error_body = resp.json()
+    except Exception:
+        error_body = {}
+
+    # from Graph APIs
+    message = error_body.get("error", {}).get("message")
+    if message is not None:
+        return str(message)
+
+    # from upload service
+    message = error_body.get("debug_info", {}).get("message")
+    if message is not None:
+        return str(message)
+
+    return resp.text
+
+
+def get_upload_token(
+    client_session: requests.Session, email: str, password: str
+) -> requests.Response:
+    url = f"{MAPILLARY_GRAPH_API_ENDPOINT}/login"
+    json_data = {"email": email, "password": password, "locale": "en_US"}
+
+    resp = client_session.post(url, json=json_data, timeout=REQUESTS_TIMEOUT)
+    resp.raise_for_status()
+
+    return resp
+
+
+def fetch_organization(
+    user_session: requests.Session, organization_id: int | str
+) -> requests.Response:
+    url = f"{MAPILLARY_GRAPH_API_ENDPOINT}/{organization_id}"
+    params = {"fields": ",".join(["slug", "description", "name"])}
+
+    resp = user_session.get(url, params=params, timeout=REQUESTS_TIMEOUT)
+    resp.raise_for_status()
+
+    return resp
+
+
+def fetch_user_or_me(
+    user_session: requests.Session, user_id: int | str | None = None
+) -> requests.Response:
+    if user_id is None:
+        url = f"{MAPILLARY_GRAPH_API_ENDPOINT}/me"
+    else:
+        url = f"{MAPILLARY_GRAPH_API_ENDPOINT}/{user_id}"
+    params = {"fields": ",".join(["id", "username"])}
+
+    resp = user_session.get(url, params=params, timeout=REQUESTS_TIMEOUT)
+    resp.raise_for_status()
+
+    return resp
+
+
+ActionType = T.Literal[
+    "upload_started_upload", "upload_finished_upload", "upload_failed_upload"
+]
+
+
+def log_event(
+    client_session: requests.Session, action_type: ActionType, properties: dict
+) -> requests.Response:
+    url = f"{MAPILLARY_GRAPH_API_ENDPOINT}/logging"
+    json_data = {"action_type": action_type, "properties": properties}
+
+    resp = client_session.post(url, json=json_data, timeout=REQUESTS_TIMEOUT)
+    resp.raise_for_status()
+
+    return resp
+
+
+def finish_upload(
+    user_session: requests.Session,
+    file_handle: str,
+    cluster_filetype: ClusterFileType,
+    organization_id: int | str | None = None,
+) -> requests.Response:
+    url = f"{MAPILLARY_GRAPH_API_ENDPOINT}/finish_upload"
+    json_data: dict[str, str | int] = {
+        "file_handle": file_handle,
+        "file_type": cluster_filetype.value,
+    }
+    if organization_id is not None:
+        json_data["organization_id"] = organization_id
+
+    resp = user_session.post(url, json=json_data, timeout=REQUESTS_TIMEOUT)
+    resp.raise_for_status()
+
+    return resp
+
+
+def jsonify_response(resp: requests.Response) -> T.Any:
+    """
+    Convert the response to JSON, raising HTTPContentError if the response is not JSON.
+    """
+    try:
+        return resp.json()
+    except requests.JSONDecodeError as ex:
+        raise HTTPContentError("Invalid JSON response", resp) from ex

{mapillary_tools-0.14.0 → mapillary_tools-0.14.4}/mapillary_tools/authenticate.py

@@ -10,7 +10,7 @@ import jsonschema
 
 import requests
 
-from . import api_v4, config, constants, exceptions
+from . import api_v4, config, constants, exceptions, http
 
 
 LOG = logging.getLogger(__name__)
@@ -77,11 +77,11 @@ def authenticate(
         # TODO: print more user information
         if profile_name in all_user_items:
             LOG.info(
-                'Profile "%s" updated: %s', profile_name, api_v4._sanitize(user_items)
+                'Profile "%s" updated: %s', profile_name, http._sanitize(user_items)
             )
         else:
             LOG.info(
-                'Profile "%s" created: %s', profile_name, api_v4._sanitize(user_items)
+                'Profile "%s" created: %s', profile_name, http._sanitize(user_items)
             )
 
 
@@ -127,21 +127,28 @@ def fetch_user_items(
 
     assert profile_name is not None, "profile_name should be set"
 
-    user_items = _verify_user_auth(_validate_profile(user_items))
-
-    LOG.info(
-        f'Uploading to profile "{profile_name}": {user_items.get("MAPSettingsUsername")} (ID: {user_items.get("MAPSettingsUserKey")})'
-    )
+    try:
+        LOG.info(f'Verifying profile "{profile_name}"...')
+        user_items = _verify_user_auth(_validate_profile(user_items))
 
-    if organization_key is not None:
-        resp = api_v4.fetch_organization(
-            user_items["user_upload_token"], organization_key
-        )
-        data = api_v4.jsonify_response(resp)
         LOG.info(
-            f"Uploading to organization: {data.get('name')} (ID: {data.get('id')})"
+            f'Uploading to profile "{profile_name}": {user_items.get("MAPSettingsUsername")} (ID: {user_items.get("MAPSettingsUserKey")})'
         )
-        user_items["MAPOrganizationKey"] = data.get("id")
+
+        if organization_key is not None:
+            with api_v4.create_user_session(user_items["user_upload_token"]) as session:
+                resp = api_v4.fetch_organization(session, organization_key)
+            data = api_v4.jsonify_response(resp)
+            LOG.info(
+                f"Uploading to organization: {data.get('name')} (ID: {data.get('id')})"
+            )
+            user_items["MAPOrganizationKey"] = data.get("id")
+
+    except requests.Timeout as ex:
+        raise exceptions.MapillaryUploadTimeoutError(str(ex)) from ex
+
+    except requests.ConnectionError as ex:
+        raise exceptions.MapillaryUploadConnectionError(str(ex)) from ex
 
     return user_items
 
@@ -158,7 +165,7 @@ def _prompt(message: str) -> str:
 
 def _validate_profile(user_items: config.UserItem) -> config.UserItem:
     try:
-        jsonschema.validate(user_items, config.UserItemSchema)
+        config.UserItemSchemaValidator.validate(user_items)
     except jsonschema.ValidationError as ex:
         raise exceptions.MapillaryBadParameterError(
             f"Invalid profile format: {ex.message}"
@@ -173,16 +180,15 @@ def _verify_user_auth(user_items: config.UserItem) -> config.UserItem:
     if constants._AUTH_VERIFICATION_DISABLED:
         return user_items
 
-    try:
-        resp = api_v4.fetch_user_or_me(
-            user_access_token=user_items["user_upload_token"]
-        )
-    except requests.HTTPError as ex:
-        if api_v4.is_auth_error(ex.response):
-            message = api_v4.extract_auth_error_message(ex.response)
-            raise exceptions.MapillaryUploadUnauthorizedError(message)
-        else:
-            raise ex
+    with api_v4.create_user_session(user_items["user_upload_token"]) as session:
+        try:
+            resp = api_v4.fetch_user_or_me(session)
+        except requests.HTTPError as ex:
+            if api_v4.is_auth_error(ex.response):
+                message = api_v4.extract_auth_error_message(ex.response)
+                raise exceptions.MapillaryUploadUnauthorizedError(message)
+            else:
+                raise ex
 
     data = api_v4.jsonify_response(resp)
 
@@ -276,16 +282,17 @@ def _prompt_login(
             if user_password:
                 break
 
-    try:
-        resp = api_v4.get_upload_token(user_email, user_password)
-    except requests.HTTPError as ex:
-        if not _enabled:
-            raise ex
+    with api_v4.create_client_session() as session:
+        try:
+            resp = api_v4.get_upload_token(session, user_email, user_password)
+        except requests.HTTPError as ex:
+            if not _enabled:
+                raise ex
 
-        if _is_login_retryable(ex):
-            return _prompt_login()
+            if _is_login_retryable(ex):
+                return _prompt_login()
 
-        raise ex
+            raise ex
 
     data = api_v4.jsonify_response(resp)
 

{mapillary_tools-0.14.0 → mapillary_tools-0.14.4}/mapillary_tools/commands/__main__.py

@@ -8,6 +8,7 @@ import requests
 
 from .. import api_v4, constants, exceptions, VERSION
 from ..upload import log_exception
+from ..utils import configure_logger, get_app_name
 from . import (
     authenticate,
     process,
@@ -31,8 +32,8 @@ mapillary_tools_commands = [
 ]
 
 
-# do not use __name__ here is because if you run tools as a module, __name__ will be "__main__"
-LOG = logging.getLogger("mapillary_tools")
+# Root logger of mapillary_tools (not including third-party libraries)
+LOG = logging.getLogger(get_app_name())
 
 
 # Handle shared arguments/options here
@@ -79,13 +80,6 @@ def add_general_arguments(parser, command):
         )
 
 
-def configure_logger(logger: logging.Logger, stream=None) -> None:
-    formatter = logging.Formatter("%(asctime)s - %(levelname)-7s - %(message)s")
-    handler = logging.StreamHandler(stream)
-    handler.setFormatter(formatter)
-    logger.addHandler(handler)
-
-
 def _log_params(argvars: dict) -> None:
     MAX_ENTRIES = 5
 
@@ -152,9 +146,7 @@ def main():
 
     args = parser.parse_args()
 
-    log_level = logging.DEBUG if args.verbose else logging.INFO
-    configure_logger(LOG, sys.stderr)
-    LOG.setLevel(log_level)
+    configure_logger(LOG, level=logging.DEBUG if args.verbose else logging.INFO)
 
     LOG.debug("%s", version_text)
     argvars = vars(args)
@@ -175,6 +167,10 @@ def main():
         log_exception(ex)
         sys.exit(ex.exit_code)
 
+    except KeyboardInterrupt:
+        LOG.info("Interrupted by user...")
+        sys.exit(130)
+
 
 if __name__ == "__main__":
     main()

{mapillary_tools-0.14.0 → mapillary_tools-0.14.4}/mapillary_tools/commands/upload.py

@@ -23,6 +23,13 @@ class Command:
             default=None,
             required=False,
         )
+        group.add_argument(
+            "--num_upload_workers",
+            help="Number of concurrent upload workers for uploading images. [default: %(default)s]",
+            default=constants.MAX_IMAGE_UPLOAD_WORKERS,
+            type=int,
+            required=False,
+        )
         group.add_argument(
             "--reupload",
             help="Re-upload data that has already been uploaded.",

{mapillary_tools-0.14.0 → mapillary_tools-0.14.4}/mapillary_tools/config.py

@@ -6,6 +6,8 @@ import sys
 import typing as T
 from typing import TypedDict
 
+import jsonschema
+
 if sys.version_info >= (3, 11):
     from typing import Required
 else:
@@ -50,6 +52,9 @@ UserItemSchema = {
 }
 
 
+UserItemSchemaValidator = jsonschema.Draft202012Validator(UserItemSchema)
+
+
 def _load_config(config_path: str) -> configparser.ConfigParser:
     config = configparser.ConfigParser()
     # Override to not change option names (by default it will lower them)

{mapillary_tools-0.14.0 → mapillary_tools-0.14.4}/mapillary_tools/constants.py

@@ -154,16 +154,18 @@ UPLOAD_CACHE_DIR: str = os.getenv(
 # The minimal upload speed is used to calculate the read timeout to avoid upload hanging:
 # timeout = upload_size / MIN_UPLOAD_SPEED
 MIN_UPLOAD_SPEED: int | None = _parse_filesize(
-    os.getenv(_ENV_PREFIX + "MIN_UPLOAD_SPEED", "50K")  # 50 KiB/s
+    os.getenv(_ENV_PREFIX + "MIN_UPLOAD_SPEED", "50K")  # 50 Kb/s
 )
+# Maximum number of parallel workers for uploading images within a single sequence.
+# NOTE: Sequences themselves are uploaded sequentially, not in parallel.
 MAX_IMAGE_UPLOAD_WORKERS: int = int(
-    os.getenv(_ENV_PREFIX + "MAX_IMAGE_UPLOAD_WORKERS", 64)
+    os.getenv(_ENV_PREFIX + "MAX_IMAGE_UPLOAD_WORKERS", 4)
 )
 # The chunk size in MB (see chunked transfer encoding https://en.wikipedia.org/wiki/Chunked_transfer_encoding)
 # for uploading data to MLY upload service.
 # Changing this size does not change the number of requests nor affect upload performance,
 # but it affects the responsiveness of the upload progress bar
-UPLOAD_CHUNK_SIZE_MB: float = float(os.getenv(_ENV_PREFIX + "UPLOAD_CHUNK_SIZE_MB", 1))
+UPLOAD_CHUNK_SIZE_MB: float = float(os.getenv(_ENV_PREFIX + "UPLOAD_CHUNK_SIZE_MB", 2))
 MAX_UPLOAD_RETRIES: int = int(os.getenv(_ENV_PREFIX + "MAX_UPLOAD_RETRIES", 200))
 MAPILLARY__ENABLE_UPLOAD_HISTORY_FOR_DRY_RUN: bool = _yes_or_no(
     os.getenv("MAPILLARY__ENABLE_UPLOAD_HISTORY_FOR_DRY_RUN", "NO")

{mapillary_tools-0.14.0 → mapillary_tools-0.14.4}/mapillary_tools/exif_read.py

@@ -871,7 +871,8 @@ class ExifRead(ExifReadFromEXIF):
 
     def _xmp_with_reason(self, reason: str) -> ExifReadFromXMP | None:
         if not self._xml_extracted:
-            LOG.debug('Extracting XMP for "%s"', reason)
+            # TODO Disabled because too verbose but still useful to know
+            # LOG.debug('Extracting XMP for "%s"', reason)
             self._cached_xml = self._extract_xmp()
             self._xml_extracted = True
 

{mapillary_tools-0.14.0 → mapillary_tools-0.14.4}/mapillary_tools/geotag/base.py

@@ -46,7 +46,7 @@ class GeotagImagesFromGeneric(abc.ABC, T.Generic[TImageExtractor]):
                 map_results,
                 desc="Extracting images",
                 unit="images",
-                disable=LOG.getEffectiveLevel() <= logging.DEBUG,
+                disable=LOG.isEnabledFor(logging.DEBUG),
                 total=len(extractors),
             )
         )
@@ -62,6 +62,8 @@ class GeotagImagesFromGeneric(abc.ABC, T.Generic[TImageExtractor]):
         try:
             return extractor.extract()
         except exceptions.MapillaryDescriptionError as ex:
+            if LOG.isEnabledFor(logging.DEBUG):
+                LOG.error(f"{cls.__name__}({image_path.name}): {ex}")
             return types.describe_error_metadata(
                 ex, image_path, filetype=types.FileType.IMAGE
             )
@@ -112,7 +114,7 @@ class GeotagVideosFromGeneric(abc.ABC, T.Generic[TVideoExtractor]):
                 map_results,
                 desc="Extracting videos",
                 unit="videos",
-                disable=LOG.getEffectiveLevel() <= logging.DEBUG,
+                disable=LOG.isEnabledFor(logging.DEBUG),
                 total=len(extractors),
             )
         )
@@ -128,6 +130,8 @@ class GeotagVideosFromGeneric(abc.ABC, T.Generic[TVideoExtractor]):
         try:
             return extractor.extract()
         except exceptions.MapillaryDescriptionError as ex:
+            if LOG.isEnabledFor(logging.DEBUG):
+                LOG.error(f"{cls.__name__}({video_path.name}): {ex}")
             return types.describe_error_metadata(
                 ex, video_path, filetype=types.FileType.VIDEO
             )

{mapillary_tools-0.14.0 → mapillary_tools-0.14.4}/mapillary_tools/geotag/factory.py

@@ -67,7 +67,7 @@ def process(
     reprocessable_paths = set(paths)
 
     for idx, option in enumerate(options):
-        if LOG.getEffectiveLevel() <= logging.DEBUG:
+        if LOG.isEnabledFor(logging.DEBUG):
             LOG.info(
                 f"==> Processing {len(reprocessable_paths)} files with source {option}..."
             )
@@ -121,6 +121,7 @@ def _is_reprocessable(metadata: types.MetadataOrError) -> bool:
                 exceptions.MapillaryGeoTaggingError,
                 exceptions.MapillaryVideoGPSNotFoundError,
                 exceptions.MapillaryExiftoolNotFoundError,
+                exceptions.MapillaryExifToolXMLNotFoundError,
             ),
         ):
             return True

{mapillary_tools-0.14.0 → mapillary_tools-0.14.4}/mapillary_tools/geotag/geotag_images_from_exiftool.py

@@ -93,7 +93,7 @@ class GeotagImagesFromExifToolRunner(GeotagImagesFromGeneric):
             LOG.warning(
                 "Failed to parse ExifTool XML: %s",
                 str(ex),
-                exc_info=LOG.getEffectiveLevel() <= logging.DEBUG,
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
             )
             rdf_by_path = {}
         else:

{mapillary_tools-0.14.0 → mapillary_tools-0.14.4}/mapillary_tools/geotag/geotag_videos_from_exiftool.py

@@ -61,21 +61,42 @@ class GeotagVideosFromExifToolXML(GeotagVideosFromGeneric):
     def find_rdf_by_path(
         cls, option: options.SourcePathOption, paths: T.Iterable[Path]
     ) -> dict[str, ET.Element]:
+        # Find RDF descriptions by path in RDF description
+        # Sources are matched based on the paths in "rdf:about" in XML elements
+        # {"source_path": "/path/to/exiftool.xml"}
+        # {"source_path": "/path/to/exiftool_xmls/"}
         if option.source_path is not None:
             return index_rdf_description_by_path([option.source_path])
 
-        elif option.pattern is not None:
+        # Find RDF descriptions by pattern matching
+        # i.e. "video.mp4" matches "/path/to/video.xml" regardless of "rdf:about"
+        # {"pattern": "/path/to/%g.xml"}
+        if option.pattern is not None:
             rdf_by_path = {}
             for path in paths:
-                source_path = option.resolve(path)
-                r = index_rdf_description_by_path([source_path])
-                rdfs = list(r.values())
-                if rdfs:
-                    rdf_by_path[exiftool_read.canonical_path(path)] = rdfs[0]
+                canonical_path = exiftool_read.canonical_path(path)
+
+                # Skip non-existent resolved source paths to avoid verbose warnings
+                resolved_source_path = option.resolve(path)
+                if not resolved_source_path.exists():
+                    continue
+
+                rdf_by_about = index_rdf_description_by_path([resolved_source_path])
+                if not rdf_by_about:
+                    continue
+
+                rdf = rdf_by_about.get(canonical_path)
+                if rdf is None:
+                    about, rdf = list(rdf_by_about.items())[0]
+                    if len(rdf_by_about) > 1:
+                        LOG.warning(
+                            f"Found {len(rdf_by_about)} RDFs in the XML source {resolved_source_path}. Using the first RDF (with rdf:about={about}) for {path}"
+                        )
+                rdf_by_path[canonical_path] = rdf
+
             return rdf_by_path
 
-        else:
-            assert False, "Either source_path or pattern must be provided"
+        raise AssertionError("Either source_path or pattern must be provided")
 
 
 class GeotagVideosFromExifToolRunner(GeotagVideosFromGeneric):
@@ -110,7 +131,7 @@ class GeotagVideosFromExifToolRunner(GeotagVideosFromGeneric):
             LOG.warning(
                 "Failed to parse ExifTool XML: %s",
                 str(ex),
-                exc_info=LOG.getEffectiveLevel() <= logging.DEBUG,
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
             )
             rdf_by_path = {}
         else:

{mapillary_tools-0.14.0 → mapillary_tools-0.14.4}/mapillary_tools/geotag/options.py

@@ -173,8 +173,11 @@ SourceOptionSchema = {
 }
 
 
+SourceOptionSchemaValidator = jsonschema.Draft202012Validator(SourceOptionSchema)
+
+
 def validate_option(instance):
-    jsonschema.validate(instance=instance, schema=SourceOptionSchema)
+    SourceOptionSchemaValidator.validate(instance=instance)
 
 
 if __name__ == "__main__":

{mapillary_tools-0.14.0 → mapillary_tools-0.14.4}/mapillary_tools/geotag/utils.py

@@ -37,26 +37,23 @@ def parse_gpx(gpx_file: Path) -> list[Track]:
     return tracks
 
 
-def index_rdf_description_by_path(
-    xml_paths: T.Sequence[Path],
-) -> dict[str, ET.Element]:
-    rdf_description_by_path: dict[str, ET.Element] = {}
+def index_rdf_description_by_path(xml_paths: T.Sequence[Path]) -> dict[str, ET.Element]:
+    rdf_by_path: dict[str, ET.Element] = {}
 
     for xml_path in utils.find_xml_files(xml_paths):
         try:
             etree = ET.parse(xml_path)
-        except ET.ParseError as ex:
-            verbose = LOG.getEffectiveLevel() <= logging.DEBUG
-            if verbose:
-                LOG.warning("Failed to parse %s", xml_path, exc_info=True)
-            else:
-                LOG.warning("Failed to parse %s: %s", xml_path, ex)
+        except Exception as ex:
+            LOG.warning(
+                f"Failed to parse {xml_path}: {ex}",
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
+            )
             continue
 
-        rdf_description_by_path.update(
+        rdf_by_path.update(
             exiftool_read.index_rdf_description_by_path_from_xml_element(
                 etree.getroot()
             )
         )
 
-    return rdf_description_by_path
+    return rdf_by_path

{mapillary_tools-0.14.0 → mapillary_tools-0.14.4}/mapillary_tools/geotag/video_extractors/gpx.py

@@ -12,7 +12,7 @@ if sys.version_info >= (3, 12):
 else:
     from typing_extensions import override
 
-from ... import exceptions, geo, telemetry, types
+from ... import exceptions, geo, telemetry, types, utils
 from ..utils import parse_gpx
 from .base import BaseVideoExtractor
 from .native import NativeVideoExtractor
@@ -59,6 +59,7 @@ class GPXVideoExtractor(BaseVideoExtractor):
             self._rebase_times(gpx_points)
             return types.VideoMetadata(
                 filename=self.video_path,
+                filesize=utils.get_file_size(self.video_path),
                 filetype=types.FileType.VIDEO,
                 points=gpx_points,
             )