nds-mapviewer 2026.1.2.dev29__tar.gz → 2026.1.2.dev30__tar.gz

{nds_mapviewer-2026.1.2.dev29/src/nds_mapviewer.egg-info → nds_mapviewer-2026.1.2.dev30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nds-mapviewer
-Version: 2026.1.2.dev29
+Version: 2026.1.2.dev30
 Summary: CLI to run the NDS MapViewer Docker container for visualizing map data (NDS.Live, GeoJSON, and more)
 Author-email: NDS Association <support@nds-association.org>
 License: Proprietary

{nds_mapviewer-2026.1.2.dev29 → nds_mapviewer-2026.1.2.dev30/src/nds_mapviewer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nds-mapviewer
-Version: 2026.1.2.dev29
+Version: 2026.1.2.dev30
 Summary: CLI to run the NDS MapViewer Docker container for visualizing map data (NDS.Live, GeoJSON, and more)
 Author-email: NDS Association <support@nds-association.org>
 License: Proprietary

{nds_mapviewer-2026.1.2.dev29 → nds_mapviewer-2026.1.2.dev30}/src/ndslive/mapviewer/container_runtime.py

@@ -63,6 +63,7 @@ def run(
     *args: str,
     check: bool = True,
     timeout: float | None = 30,
+    extra_env: dict[str, str] | None = None,
 ) -> subprocess.CompletedProcess[str]:
     """Run a container-runtime command, capturing stdout and stderr.
 
@@ -75,14 +76,20 @@ def run(
         Raise :class:`subprocess.CalledProcessError` on non-zero exit.
     timeout:
         Seconds before the process is killed (``None`` = no limit).
+    extra_env:
+        Additional environment variables merged into the current env.
     """
     cmd = [detect_runtime(), *args]
+    env = None
+    if extra_env:
+        env = {**os.environ, **extra_env}
     return subprocess.run(
         cmd,
         capture_output=True,
         text=True,
         check=check,
         timeout=timeout,
+        env=env,
     )
 
 

{nds_mapviewer-2026.1.2.dev29 → nds_mapviewer-2026.1.2.dev30}/src/ndslive/mapviewer/docker_client.py

@@ -182,6 +182,9 @@ def get_image_tag(edition: str, version: str, arch: str | None = None) -> str:
 # Registry / auth helpers
 # ---------------------------------------------------------------------------
 
+_MANIFEST_ENV = {"DOCKER_CLI_EXPERIMENTAL": "enabled"}
+
+
 def _verify_registry_access(edition: str) -> bool:
     """Verify actual registry access via a quick manifest inspect (3 s timeout)."""
     import concurrent.futures
@@ -190,7 +193,8 @@ def _verify_registry_access(edition: str) -> bool:
         try:
             get_docker_client()
             tag = get_image_tag(edition, "latest")
-            rt.run("manifest", "inspect", tag, timeout=3)
+            rt.run("manifest", "inspect", tag, timeout=3,
+                   extra_env=_MANIFEST_ENV)
             return True
         except Exception:
             return False
@@ -299,6 +303,36 @@ def image_exists(edition: str, version: str = "latest", arch: str | None = None)
         return False
 
 
+def _parse_image_entry(img: dict) -> tuple[str, float]:
+    """Extract (tag, size_mb) from Docker or Podman image JSON.
+
+    Docker ``images --format json`` produces keys like
+    ``Tag``, ``Repository``, ``Size`` (human-readable string).
+
+    Podman ``images --format json`` produces keys like
+    ``names`` (list of full refs), ``size`` (int bytes).
+    """
+    # Docker format: {"Repository": "...", "Tag": "latest-arm64", "Size": "1.2GB"}
+    tag_str = img.get("Tag", "")
+
+    if not tag_str:
+        # Podman format: {"names": ["registry/image:tag"], "size": 123456}
+        names = img.get("names") or img.get("Names") or []
+        if names:
+            # names is a list of full references like "registry/image:tag"
+            ref = names[0] if isinstance(names, list) else names
+            if ":" in ref:
+                tag_str = ref.rsplit(":", 1)[-1]
+
+    size = img.get("Size") or img.get("size") or 0
+    if isinstance(size, str):
+        size_mb = round(rt.parse_size_string(size) / (1024 * 1024), 1)
+    else:
+        size_mb = round(size / (1024 * 1024), 1)
+
+    return tag_str, size_mb
+
+
 def list_local_image_versions(edition: str | None = None) -> list[dict]:
     """List locally available nds-mapviewer images.
 
@@ -318,38 +352,25 @@ def list_local_image_versions(edition: str | None = None) -> list[dict]:
             continue
         repo = f"{registry}/{IMAGE_NAME}"
         try:
-            data = rt.run_json(
+            raw = rt.run(
                 "images", "--format", "json",
                 "--filter", f"reference={repo}",
                 timeout=10,
             )
-            # Some runtimes return a list, others return newline-delimited JSON
-            if isinstance(data, dict):
-                data = [data]
-        except (json.JSONDecodeError, subprocess.CalledProcessError):
-            # Try newline-delimited JSON fallback
-            try:
-                raw = rt.run(
-                    "images", "--format", "json",
-                    "--filter", f"reference={repo}",
-                    timeout=10,
-                )
-                data = [json.loads(line) for line in raw.stdout.strip().splitlines() if line.strip()]
-            except Exception:
+            # Docker outputs newline-delimited JSON objects,
+            # Podman outputs a single JSON array
+            stdout = raw.stdout.strip()
+            if not stdout:
                 continue
+            if stdout.startswith("["):
+                data = json.loads(stdout)
+            else:
+                data = [json.loads(line) for line in stdout.splitlines() if line.strip()]
         except Exception:
             continue
 
         for img in data:
-            # Handle different output formats from docker/podman
-            tag_str = img.get("Tag", "")
-            repo_str = img.get("Repository", "")
-            size = img.get("Size", "0")
-            if isinstance(size, str):
-                size_mb = round(rt.parse_size_string(size) / (1024 * 1024), 1)
-            else:
-                size_mb = round(size / (1024 * 1024), 1)
-
+            tag_str, size_mb = _parse_image_entry(img)
             if not tag_str or tag_str == "<none>":
                 continue
             version_str = re.sub(r"-(amd64|arm64)$", "", tag_str)
@@ -426,7 +447,8 @@ def get_remote_digest(
     ensure_logged_in(edition)
     image_tag = get_image_tag(edition, version, arch)
     try:
-        result = rt.run("manifest", "inspect", image_tag, timeout=15)
+        result = rt.run("manifest", "inspect", image_tag, timeout=15,
+                         extra_env=_MANIFEST_ENV)
         # Parse manifest JSON to extract digest
         try:
             manifest = json.loads(result.stdout)

{nds_mapviewer-2026.1.2.dev29 → nds_mapviewer-2026.1.2.dev30}/src/ndslive/mapviewer/viewer.py

@@ -305,10 +305,11 @@ class MapViewer:
                         f"Recent logs:\n{logs}"
                     )
                 else:
+                    from . import container_runtime as _rt
                     raise ConfigError(
                         f"Container did not become ready within {timeout}s.\n"
                         f"The MapViewer is still starting up. Try increasing the timeout or check:\n"
-                        f"  docker logs {self._name}"
+                        f"  {_rt.detect_runtime()} logs {self._name}"
                     )
 
     def stop(self, remove: bool = True) -> None:

{nds_mapviewer-2026.1.2.dev29 → nds_mapviewer-2026.1.2.dev30}/tests/test_docker_client.py

@@ -1,5 +1,6 @@
 """Tests for container runtime operations (requires Docker or Podman)."""
 
+import json
 import subprocess
 
 import pytest
@@ -314,3 +315,94 @@ class TestContainerInfo:
         assert info.name == "test"
         assert info.status == "running"
         assert info.host_port == 8080
+
+
+class TestParseImageEntry:
+    """Tests for _parse_image_entry with Docker and Podman JSON formats."""
+
+    def test_docker_format(self):
+        """Docker image JSON uses Tag/Repository/Size keys."""
+        img = {
+            "Repository": "artifactory.nds-association.org/ndslive-dockerreg/nds-mapviewer",
+            "Tag": "latest-arm64",
+            "Size": "1.2GB",
+        }
+        tag, size_mb = dc._parse_image_entry(img)
+        assert tag == "latest-arm64"
+        assert size_mb > 0
+
+    def test_podman_format(self):
+        """Podman image JSON uses names (list) and size (int) keys."""
+        img = {
+            "names": [
+                "artifactory.nds-association.org/ndslive-dockerreg/nds-mapviewer:latest-arm64"
+            ],
+            "size": 512 * 1024 * 1024,
+            "digest": "sha256:abc123",
+        }
+        tag, size_mb = dc._parse_image_entry(img)
+        assert tag == "latest-arm64"
+        assert size_mb == 512.0
+
+    def test_podman_format_capitalized_names(self):
+        """Podman may also use capitalized Names key."""
+        img = {
+            "Names": [
+                "registry.example.com/image:v1.0-amd64"
+            ],
+            "size": 256 * 1024 * 1024,
+        }
+        tag, size_mb = dc._parse_image_entry(img)
+        assert tag == "v1.0-amd64"
+        assert size_mb == 256.0
+
+    def test_empty_entry(self):
+        """Empty dict returns empty tag."""
+        tag, size_mb = dc._parse_image_entry({})
+        assert tag == ""
+        assert size_mb == 0.0
+
+
+class TestListLocalImagesFormats:
+    """Test list_local_image_versions with mocked Docker and Podman output."""
+
+    def test_docker_newline_delimited_json(self, docker_client, mocker):
+        """Docker outputs newline-delimited JSON objects."""
+        registry = dc.REGISTRIES["community"]
+        mock_result = mocker.MagicMock()
+        mock_result.stdout = (
+            f'{{"Repository":"{registry}/nds-mapviewer","Tag":"latest-arm64","Size":"1.2GB"}}\n'
+            f'{{"Repository":"{registry}/nds-mapviewer","Tag":"dev-arm64","Size":"1.1GB"}}\n'
+        )
+        mock_result.returncode = 0
+        mocker.patch.object(rt, "run", return_value=mock_result)
+
+        results = dc.list_local_image_versions("community")
+        assert len(results) == 2
+        assert results[0]["version"] == "latest"
+        assert results[1]["version"] == "dev"
+
+    def test_podman_json_array(self, docker_client, mocker):
+        """Podman outputs a single JSON array."""
+        registry = dc.REGISTRIES["community"]
+        mock_result = mocker.MagicMock()
+        mock_result.stdout = json.dumps([
+            {
+                "names": [f"{registry}/nds-mapviewer:latest-arm64"],
+                "size": 512 * 1024 * 1024,
+                "digest": "sha256:abc",
+            },
+            {
+                "names": [f"{registry}/nds-mapviewer:dev-arm64"],
+                "size": 400 * 1024 * 1024,
+                "digest": "sha256:def",
+            },
+        ])
+        mock_result.returncode = 0
+        mocker.patch.object(rt, "run", return_value=mock_result)
+
+        results = dc.list_local_image_versions("community")
+        assert len(results) == 2
+        assert results[0]["version"] == "latest"
+        assert results[0]["size_mb"] == 512.0
+        assert results[1]["version"] == "dev"