mapillary-downloader 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

mapillary_downloader/client.py

@@ -22,11 +22,12 @@ class MapillaryClient:
         self.session = requests.Session()
         self.session.headers.update({"Authorization": f"OAuth {access_token}"})
 
-    def get_user_images(self, username, bbox=None, limit=2000):
+    def get_user_images(self, username, quality, bbox=None, limit=2000):
         """Get images uploaded by a specific user.
 
         Args:
             username: Mapillary username
+            quality: Image quality (256, 1024, 2048, or original)
             bbox: Optional bounding box [west, south, east, north]
             limit: Number of results per page (max 2000)
 
@@ -56,10 +57,7 @@ class MapillaryClient:
                     "computed_rotation",
                     "height",
                     "width",
-                    "thumb_256_url",
-                    "thumb_1024_url",
-                    "thumb_2048_url",
-                    "thumb_original_url",
+                    f"thumb_{quality}_url",
                 ]
             ),
         }

mapillary_downloader/downloader.py

@@ -5,8 +5,10 @@ import json
 import logging
 import os
 import shutil
+import threading
 import time
 from pathlib import Path
+import requests
 from mapillary_downloader.utils import format_size, format_time, safe_json_save
 from mapillary_downloader.ia_meta import generate_ia_metadata
 from mapillary_downloader.ia_check import check_ia_exists
@@ -146,6 +148,65 @@ class MapillaryDownloader:
         # Write atomically using utility function
         safe_json_save(self.progress_file, progress)
 
+    def _submit_metadata_batch(self, file_handle, quality_field, pool, convert_webp, process_results, base_submitted):
+        """Read metadata lines from current position, submit to workers.
+
+        Args:
+            file_handle: Open file positioned at read point
+            quality_field: Field name for quality URL (e.g., "thumb_1024_url")
+            pool: Worker pool to submit to
+            convert_webp: Whether to convert to webp
+            process_results: Callback to drain result queue
+            base_submitted: Running total for cumulative logging
+
+        Returns:
+            tuple: (submitted_count, skipped_count) for this batch
+        """
+        submitted = 0
+        skipped = 0
+
+        for line in file_handle:
+            line = line.strip()
+            if not line:
+                continue
+
+            try:
+                image = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+
+            if image.get("__complete__"):
+                continue
+
+            image_id = image.get("id")
+            if not image_id:
+                continue
+
+            if image_id in self.downloaded:
+                skipped += 1
+                continue
+
+            if not image.get(quality_field):
+                continue
+
+            work_item = (
+                image,
+                str(self.output_dir),
+                self.quality,
+                convert_webp,
+                self.client.access_token,
+            )
+            pool.submit(work_item)
+            submitted += 1
+
+            total = base_submitted + submitted
+            if total % 1000 == 0:
+                logger.info(f"Queue: submitted {total:,} images")
+
+            process_results()
+
+        return submitted, skipped
+
     def download_user_data(self, bbox=None, convert_webp=False):
         """Download all images for a user using streaming queue-based architecture.
 
@@ -159,7 +220,7 @@ class MapillaryDownloader:
         # Check if collection already exists on Internet Archive
         if self.check_ia and self.collection_name:
             logger.info(f"Checking if {self.collection_name} exists on Internet Archive...")
-            if check_ia_exists(self.collection_name):
+            if check_ia_exists(requests.Session(), self.collection_name):
                 logger.info("Collection already exists on archive.org, skipping download")
                 return
 
@@ -187,13 +248,13 @@ class MapillaryDownloader:
         total_bytes = 0
         failed_count = 0
         submitted = 0
+        skipped_count = 0
 
         try:
             # Step 3a: Fetch metadata from API in parallel (write-only, don't block on queue)
-            if not api_complete:
-                import threading
+            api_fetch_complete = threading.Event()
 
-                api_fetch_complete = threading.Event()
+            if not api_complete:
                 new_images_count = [0]  # Mutable so thread can update it
 
                 def fetch_api_metadata():
@@ -201,7 +262,7 @@ class MapillaryDownloader:
                     try:
                         logger.debug("API fetch thread starting")
                         with open(self.metadata_file, "a") as meta_f:
-                            for image in self.client.get_user_images(self.username, bbox=bbox):
+                            for image in self.client.get_user_images(self.username, self.quality, bbox=bbox):
                                 new_images_count[0] += 1
 
                                 # Save metadata (don't dedupe here, let the tailer handle it)
@@ -221,7 +282,7 @@ class MapillaryDownloader:
                 api_thread = threading.Thread(target=fetch_api_metadata, daemon=True)
                 api_thread.start()
             else:
-                api_fetch_complete = None
+                api_fetch_complete.set()
 
             # Step 3b: Tail metadata file and submit to workers
             logger.debug("Starting metadata tail and download queue feeder")
@@ -244,9 +305,10 @@ class MapillaryDownloader:
                         total_bytes += bytes_dl
 
                         # Log every download for first 10, then every 100
+                        total_downloaded = len(self.downloaded)
                         should_log = downloaded_count <= 10 or downloaded_count % 100 == 0
                         if should_log:
-                            logger.info(f"Downloaded: {downloaded_count:,} ({format_size(total_bytes)})")
+                            logger.info(f"Downloaded: {total_downloaded:,} ({format_size(total_bytes)} this session)")
 
                         if downloaded_count % 100 == 0:
                             pool.check_throughput(downloaded_count)
@@ -260,117 +322,20 @@ class MapillaryDownloader:
 
             # Tail the metadata file and submit to workers
             while True:
-                # Check if API fetch is done and we've processed everything
-                if api_fetch_complete and api_fetch_complete.is_set():
-                    # Read any remaining lines
-                    if self.metadata_file.exists():
-                        with open(self.metadata_file) as f:
-                            f.seek(last_position)
-                            for line in f:
-                                line = line.strip()
-                                if not line:
-                                    continue
-
-                                try:
-                                    image = json.loads(line)
-                                except json.JSONDecodeError:
-                                    # Incomplete line, will retry
-                                    continue
-
-                                # Skip completion marker
-                                if image.get("__complete__"):
-                                    continue
-
-                                image_id = image.get("id")
-                                if not image_id:
-                                    continue
-
-                                # Skip if already downloaded or no quality URL
-                                if image_id in self.downloaded:
-                                    downloaded_count += 1
-                                    continue
-                                if not image.get(quality_field):
-                                    continue
-
-                                # Submit to workers
-                                work_item = (
-                                    image,
-                                    str(self.output_dir),
-                                    self.quality,
-                                    convert_webp,
-                                    self.client.access_token,
-                                )
-                                pool.submit(work_item)
-                                submitted += 1
-
-                                if submitted % 1000 == 0:
-                                    logger.info(f"Queue: submitted {submitted:,} images")
-
-                                # Process results while submitting
-                                process_results()
-
-                            last_position = f.tell()
-
-                    # API done and all lines processed, break
-                    break
-
-                # API still running or API was already complete, tail the file
                 if self.metadata_file.exists():
                     with open(self.metadata_file) as f:
                         f.seek(last_position)
-                        for line in f:
-                            line = line.strip()
-                            if not line:
-                                continue
-
-                            try:
-                                image = json.loads(line)
-                            except json.JSONDecodeError:
-                                # Incomplete line, will retry next iteration
-                                continue
-
-                            # Skip completion marker
-                            if image.get("__complete__"):
-                                continue
-
-                            image_id = image.get("id")
-                            if not image_id:
-                                continue
-
-                            # Skip if already downloaded or no quality URL
-                            if image_id in self.downloaded:
-                                downloaded_count += 1
-                                continue
-                            if not image.get(quality_field):
-                                continue
-
-                            # Submit to workers
-                            work_item = (
-                                image,
-                                str(self.output_dir),
-                                self.quality,
-                                convert_webp,
-                                self.client.access_token,
-                            )
-                            pool.submit(work_item)
-                            submitted += 1
-
-                            if submitted % 1000 == 0:
-                                logger.info(f"Queue: submitted {submitted:,} images")
-
-                            # Process results while submitting
-                            process_results()
-
+                        batch_submitted, batch_skipped = self._submit_metadata_batch(
+                            f, quality_field, pool, convert_webp, process_results, submitted
+                        )
+                        submitted += batch_submitted
+                        skipped_count += batch_skipped
                         last_position = f.tell()
 
-                # If API is already complete, we've read the whole file, so break
-                if api_fetch_complete is None:
+                if api_fetch_complete.is_set():
                     break
 
-                # Sleep briefly before next tail iteration
                 time.sleep(0.1)
-
-                # Process any results that came in
                 process_results()
 
             # Send shutdown signals
@@ -397,7 +362,7 @@ class MapillaryDownloader:
                     total_bytes += bytes_dl
 
                     if downloaded_count % 100 == 0:
-                        logger.info(f"Downloaded: {downloaded_count:,} ({format_size(total_bytes)})")
+                        logger.info(f"Downloaded: {len(self.downloaded):,} ({format_size(total_bytes)} this session)")
                         pool.check_throughput(downloaded_count)
                         # Save progress every 5 minutes
                         if time.time() - self._last_save_time >= 300:
@@ -414,7 +379,10 @@ class MapillaryDownloader:
         self._save_progress()
         elapsed = time.time() - start_time
 
-        logger.info(f"Complete! Downloaded {downloaded_count:,} ({format_size(total_bytes)}), failed {failed_count:,}")
+        logger.info(
+            f"Complete! Downloaded {downloaded_count:,} this session ({format_size(total_bytes)}), "
+            f"{len(self.downloaded):,} total, skipped {skipped_count:,}, failed {failed_count:,}"
+        )
         logger.info(f"Total time: {format_time(elapsed)}")
 
         # Tar sequence directories for efficient IA uploads

mapillary_downloader/ia_check.py

@@ -6,20 +6,20 @@ import requests
 logger = logging.getLogger("mapillary_downloader")
 
 
-def check_ia_exists(collection_name):
+def check_ia_exists(session, collection_name):
     """Check if a collection exists on Internet Archive.
 
     Args:
+        session: requests.Session for connection pooling
         collection_name: Name of the collection (e.g., mapillary-username-original-webp)
 
     Returns:
         Boolean indicating if the collection exists on IA
     """
-    # IA identifier format
     ia_url = f"https://archive.org/metadata/{collection_name}"
 
     try:
-        response = requests.get(ia_url, timeout=10)
+        response = session.get(ia_url, timeout=10)
         # If we get a 200, the item exists
         if response.status_code == 200:
             data = response.json()

mapillary_downloader/ia_stats.py

@@ -3,6 +3,7 @@
 import json
 import logging
 import re
+import requests
 from mapillary_downloader.utils import safe_json_save, http_get_with_retry, format_size
 from mapillary_downloader.downloader import get_cache_dir
 
@@ -11,9 +12,12 @@ logger = logging.getLogger("mapillary_downloader")
 CACHE_FILE = get_cache_dir() / ".stats.json"
 
 
-def search_ia_collections():
+def search_ia_collections(session):
     """Search IA for all mapillary_downloader collections.
 
+    Args:
+        session: requests.Session for connection pooling
+
     Returns:
         List of dicts with: identifier, description, item_size, collection
     """
@@ -27,7 +31,7 @@ def search_ia_collections():
         "output": "json",
     }
 
-    response = http_get_with_retry(url, params=params, max_retries=3)
+    response = http_get_with_retry(session, url, params=params, max_retries=3)
     data = response.json()
 
     collections = data["response"]["docs"]
@@ -36,10 +40,11 @@ def search_ia_collections():
     return collections
 
 
-def fetch_uploader(identifier):
+def fetch_uploader(session, identifier):
     """Fetch uploader email from item metadata.
 
     Args:
+        session: requests.Session for connection pooling
         identifier: IA item identifier
 
     Returns:
@@ -47,7 +52,7 @@ def fetch_uploader(identifier):
     """
     url = f"https://archive.org/metadata/{identifier}/metadata/uploader"
     try:
-        response = http_get_with_retry(url, max_retries=2)
+        response = http_get_with_retry(session, url, max_retries=2)
         data = response.json()
         return data.get("result")
     except Exception:
@@ -195,10 +200,11 @@ def aggregate_stats(cache):
     return stats
 
 
-def format_stats(stats, cache):
+def format_stats(session, stats, cache):
     """Format statistics as human-readable text.
 
     Args:
+        session: requests.Session for connection pooling
         stats: Dict from aggregate_stats()
         cache: Dict of collection data
 
@@ -257,7 +263,7 @@ def format_stats(stats, cache):
         logger.info(f"Fetching uploader info for {len(need_uploader_fetch)} items...")
         for i, identifier in enumerate(need_uploader_fetch, 1):
             logger.info(f"  [{i}/{len(need_uploader_fetch)}] {identifier}")
-            uploader = fetch_uploader(identifier)
+            uploader = fetch_uploader(session, identifier)
             if uploader:
                 cache[identifier]["uploader"] = uploader
         # Save updated cache with uploaders
@@ -307,9 +313,11 @@ def show_stats(refresh=True):
     Args:
         refresh: If True, fetch fresh data from IA. If False, use cache only.
     """
+    session = requests.Session()
+
     if refresh:
         try:
-            ia_collections = search_ia_collections()
+            ia_collections = search_ia_collections(session)
             cache = update_cache(ia_collections)
         except Exception as e:
             logger.error(f"Failed to fetch IA data: {e}")
@@ -323,4 +331,4 @@ def show_stats(refresh=True):
         return
 
     stats = aggregate_stats(cache)
-    print(format_stats(stats, cache))
+    print(format_stats(session, stats, cache))

mapillary_downloader/logging_config.py

@@ -15,6 +15,7 @@ class ColoredFormatter(logging.Formatter):
         "DEBUG": "\033[94m",  # Blue
         "RESET": "\033[0m",
     }
+    CYAN = "\033[96m"
 
     def __init__(self, fmt=None, datefmt=None, use_color=True):
         """Initialize the formatter.
@@ -41,6 +42,10 @@ class ColoredFormatter(logging.Formatter):
             if levelname in self.COLORS:
                 record.levelname = f"{self.COLORS[levelname]}{levelname}{self.COLORS['RESET']}"
 
+            # Color API messages differently so they stand out
+            if record.msg.startswith("API"):
+                record.msg = f"{self.CYAN}{record.msg}{self.COLORS['RESET']}"
+
         return super().format(record)
 
 

mapillary_downloader/metadata_reader.py

@@ -65,53 +65,6 @@ class MetadataReader:
         except Exception:
             return False
 
-    def iter_images(self, quality_field=None, downloaded_ids=None):
-        """Stream images from metadata file with filtering.
-
-        Args:
-            quality_field: Optional field to check exists (e.g., 'thumb_1024_url')
-            downloaded_ids: Optional set of already downloaded IDs to skip
-
-        Yields:
-            Image metadata dicts that pass filters
-        """
-        if not self.metadata_file.exists():
-            return
-
-        # Handle gzipped files
-        if self.metadata_file.suffix == ".gz":
-            file_handle = gzip.open(self.metadata_file, "rt")
-        else:
-            file_handle = open(self.metadata_file)
-
-        with file_handle as f:
-            for line in f:
-                line = line.strip()
-                if not line:
-                    continue
-
-                image = json.loads(line)
-
-                # Check for completion marker
-                if image.get("__complete__"):
-                    self.is_complete = True
-                    logger.debug("Found API fetch completion marker")
-                    continue
-
-                image_id = image.get("id")
-                if not image_id:
-                    continue
-
-                # Filter by downloaded status
-                if downloaded_ids and image_id in downloaded_ids:
-                    continue
-
-                # Filter by quality field availability
-                if quality_field and not image.get(quality_field):
-                    continue
-
-                yield image
-
     def get_all_ids(self):
         """Get set of all image IDs in metadata file.
 

mapillary_downloader/utils.py

@@ -5,7 +5,6 @@ import logging
 import os
 import time
 from pathlib import Path
-import requests
 from requests.exceptions import RequestException
 
 logger = logging.getLogger("mapillary_downloader")
@@ -77,16 +76,16 @@ def safe_json_save(file_path, data):
     temp_file.replace(file_path)
 
 
-def http_get_with_retry(url, params=None, max_retries=5, base_delay=1.0, timeout=60, session=None):
+def http_get_with_retry(session, url, params=None, max_retries=5, base_delay=1.0, timeout=60):
     """HTTP GET with exponential backoff retry.
 
     Args:
+        session: requests.Session for connection pooling
         url: URL to fetch
         params: Optional query parameters
         max_retries: Maximum retry attempts (default: 5)
         base_delay: Initial delay in seconds (default: 1.0)
         timeout: Request timeout in seconds (default: 60)
-        session: Optional requests.Session for connection pooling
 
     Returns:
         requests.Response object
@@ -94,10 +93,9 @@ def http_get_with_retry(url, params=None, max_retries=5, base_delay=1.0, timeout
     Raises:
         requests.RequestException: If all retries exhausted
     """
-    getter = session or requests
     for attempt in range(max_retries):
         try:
-            response = getter.get(url, params=params, timeout=timeout)
+            response = session.get(url, params=params, timeout=timeout)
             response.raise_for_status()
             return response
         except RequestException as e:

mapillary_downloader/webp_converter.py

@@ -17,25 +17,20 @@ def check_cwebp_available():
     return shutil.which("cwebp") is not None
 
 
-def convert_to_webp(jpg_path, output_path=None, delete_original=True):
+def convert_to_webp(jpg_path, output_path, delete_original=True):
     """Convert a JPG image to WebP format, preserving EXIF metadata.
 
     Args:
         jpg_path: Path to the JPG file
-        output_path: Optional path for the WebP output. If None, uses jpg_path with .webp extension
+        output_path: Path for the WebP output
         delete_original: Whether to delete the original JPG after conversion (default: True)
 
     Returns:
         Path object to the new WebP file, or None if conversion failed
     """
     jpg_path = Path(jpg_path)
-
-    if output_path is None:
-        webp_path = jpg_path.with_suffix(".webp")
-    else:
-        webp_path = Path(output_path)
-        # Ensure output directory exists
-        webp_path.parent.mkdir(parents=True, exist_ok=True)
+    webp_path = Path(output_path)
+    webp_path.parent.mkdir(parents=True, exist_ok=True)
 
     try:
         # Convert with cwebp, preserving all metadata
@@ -43,7 +38,6 @@ def convert_to_webp(jpg_path, output_path=None, delete_original=True):
             ["cwebp", "-metadata", "all", str(jpg_path), "-o", str(webp_path)],
             capture_output=True,
             text=True,
-            timeout=60,
         )
 
         if result.returncode != 0:
@@ -55,9 +49,6 @@ def convert_to_webp(jpg_path, output_path=None, delete_original=True):
             jpg_path.unlink()
         return webp_path
 
-    except subprocess.TimeoutExpired:
-        logger.error(f"cwebp conversion timed out for {jpg_path}")
-        return None
     except Exception as e:
         logger.error(f"Error converting {jpg_path} to WebP: {e}")
         return None

mapillary_downloader/worker.py

@@ -106,7 +106,7 @@ def download_and_convert_image(image_data, output_dir, quality, convert_webp, se
 
         try:
             # Use retry logic with 3 attempts for image downloads
-            response = http_get_with_retry(image_url, max_retries=3, base_delay=1.0, timeout=60, session=session)
+            response = http_get_with_retry(session, image_url, max_retries=3, base_delay=1.0, timeout=60)
 
             with open(jpg_path, "wb") as f:
                 for chunk in response.iter_content(chunk_size=8192):

{mapillary_downloader-0.8.0.dist-info → mapillary_downloader-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapillary_downloader
-Version: 0.8.0
+Version: 0.9.0
 Summary: Archive user data from Mapillary
 Author-email: Gareth Davidson <gaz@bitplane.net>
 Requires-Python: >=3.10

mapillary_downloader-0.9.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+mapillary_downloader/__init__.py,sha256=KEjiBRghXDeA7E15RJeLBfQm-yNJkowZarL59QOh_1w,120
+mapillary_downloader/__main__.py,sha256=iuDGZoFVu8q_dTvJuExSpj4Jx1x9xASSjUITRGwd0RA,4864
+mapillary_downloader/client.py,sha256=nZTcSnRNdWHjqENSOtXA3FXKfHXZQT6QPWWS59mtSyM,4707
+mapillary_downloader/downloader.py,sha256=9zpmfO3oaGQVJ52fkaCtpwNkx4vyP_0gzS4GVQ3M4I4,16788
+mapillary_downloader/exif_writer.py,sha256=Dwh6RFotCnI4HVRQNqmsuWy05BPQYh3tMOQlKUk0gL8,5213
+mapillary_downloader/ia_check.py,sha256=MmwN9QWevfSlE_XBb4Wzwbm9R6mjICLvlET7M_Ncy0A,1138
+mapillary_downloader/ia_meta.py,sha256=DTmFwIKN03aNgBaerQWF5x_hveDpjvrMBTdRAgHoFRk,6365
+mapillary_downloader/ia_stats.py,sha256=4bqXl_o6CIZX8lX9Sgl2qGafL1j7mWehRMRDXZnV-so,10978
+mapillary_downloader/logging_config.py,sha256=dkhmHY-keCQzfv8LNXr52BkJNo4mwGiogPKoED3ZdMw,2533
+mapillary_downloader/metadata_reader.py,sha256=YUVdsQtI6D8r5tbhcq5A4CgMBNGDVBLelVzeC7JgMoA,3422
+mapillary_downloader/tar_sequences.py,sha256=hh77hfj0DFSPrPRfbGrOhvnZMctKESgO0gSpJXUxCCs,4886
+mapillary_downloader/utils.py,sha256=MP_TEXwoDWb-a7vQA9F2t79w3AOHU5u7OHKiLCmjhls,2996
+mapillary_downloader/webp_converter.py,sha256=fvl5YqTh4zh7ESAJ1ONmRU6uioB2km3nv0hUKQ1jFzs,1555
+mapillary_downloader/worker.py,sha256=bVfVqzmvSIzu5OGGxbWcFfwWjq2TNhzdiFD8ZoWXkLc,5327
+mapillary_downloader/worker_pool.py,sha256=QnqYcPCi3GNu2e8GNG_qQ8v680PWzCZcGE5KeskqZxU,7868
+mapillary_downloader/xmp_writer.py,sha256=6kjAP3JpqVnknDETgjd8Ze-P7c1kMbmvuQ14GF0dMoA,5163
+mapillary_downloader-0.9.0.dist-info/entry_points.txt,sha256=PdYtxOXHMJrUhmiPO4G-F98VuhUI4MN9D_T4KPrVZ5w,75
+mapillary_downloader-0.9.0.dist-info/licenses/LICENSE.md,sha256=7_BIuQ-veOrsF-WarH8kTkm0-xrCLvJ1PFE1C4Ebs64,146
+mapillary_downloader-0.9.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+mapillary_downloader-0.9.0.dist-info/METADATA,sha256=z0RrCNVh8S3Uom8anffB8ieILTP-I_mqx1bu8rJJvvw,5791
+mapillary_downloader-0.9.0.dist-info/RECORD,,

mapillary_downloader-0.8.0.dist-info/RECORD

@@ -1,21 +0,0 @@
-mapillary_downloader/__init__.py,sha256=KEjiBRghXDeA7E15RJeLBfQm-yNJkowZarL59QOh_1w,120
-mapillary_downloader/__main__.py,sha256=iuDGZoFVu8q_dTvJuExSpj4Jx1x9xASSjUITRGwd0RA,4864
-mapillary_downloader/client.py,sha256=a5n43FLHP45EHodEjl0ieziBK-b6Ey-rZJwYB6EFhNI,4743
-mapillary_downloader/downloader.py,sha256=l6MT3dFOB-lZfoLEVVGIkioKSXcDu30Q9xc2MZ17iGI,18897
-mapillary_downloader/exif_writer.py,sha256=Dwh6RFotCnI4HVRQNqmsuWy05BPQYh3tMOQlKUk0gL8,5213
-mapillary_downloader/ia_check.py,sha256=L2MEbG_KmlAd5NLmo2HQkO8HWvRN0brE5wXXoyNMbq8,1100
-mapillary_downloader/ia_meta.py,sha256=DTmFwIKN03aNgBaerQWF5x_hveDpjvrMBTdRAgHoFRk,6365
-mapillary_downloader/ia_stats.py,sha256=kjbNUVXtZziWxTx1yi2TLTZt_F0BWjrv1WWyy6ZeCLY,10678
-mapillary_downloader/logging_config.py,sha256=Z-wNq34nt7aIhJWdeKc1feTY46P9-Or7HtiX7eUFjEI,2324
-mapillary_downloader/metadata_reader.py,sha256=Re-HN0Vfc7Hs1eOut7uOoW7jWJ2PIbKoNzC7Ak3ah5o,4933
-mapillary_downloader/tar_sequences.py,sha256=hh77hfj0DFSPrPRfbGrOhvnZMctKESgO0gSpJXUxCCs,4886
-mapillary_downloader/utils.py,sha256=qQ_ewhN0b0r4KLfBtf9tjwewF9PHVF1swLt71t8x9F0,3058
-mapillary_downloader/webp_converter.py,sha256=vYLLQxDmdnqRz0nm7wXwRUd4x9mQZNah-DrncpA8sNs,1901
-mapillary_downloader/worker.py,sha256=rMqeDj5pfLoEPwKOGN28R7yMZ_XDSzLayrL5ht0cqN0,5335
-mapillary_downloader/worker_pool.py,sha256=QnqYcPCi3GNu2e8GNG_qQ8v680PWzCZcGE5KeskqZxU,7868
-mapillary_downloader/xmp_writer.py,sha256=6kjAP3JpqVnknDETgjd8Ze-P7c1kMbmvuQ14GF0dMoA,5163
-mapillary_downloader-0.8.0.dist-info/entry_points.txt,sha256=PdYtxOXHMJrUhmiPO4G-F98VuhUI4MN9D_T4KPrVZ5w,75
-mapillary_downloader-0.8.0.dist-info/licenses/LICENSE.md,sha256=7_BIuQ-veOrsF-WarH8kTkm0-xrCLvJ1PFE1C4Ebs64,146
-mapillary_downloader-0.8.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-mapillary_downloader-0.8.0.dist-info/METADATA,sha256=cF1WSbpDbCjL9zCs2R8s8w1768-qfpUWgG_R1mL_q_w,5791
-mapillary_downloader-0.8.0.dist-info/RECORD,,