nds-mapviewer 2026.1.3.dev45__tar.gz → 2026.1.3.dev47__tar.gz

{nds_mapviewer-2026.1.3.dev45/src/nds_mapviewer.egg-info → nds_mapviewer-2026.1.3.dev47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nds-mapviewer
-Version: 2026.1.3.dev45
+Version: 2026.1.3.dev47
 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.3.dev45 → nds_mapviewer-2026.1.3.dev47/src/nds_mapviewer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nds-mapviewer
-Version: 2026.1.3.dev45
+Version: 2026.1.3.dev47
 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.3.dev45 → nds_mapviewer-2026.1.3.dev47}/src/ndslive/mapviewer/container_runtime.py

@@ -42,18 +42,44 @@ def _runtime_is_responsive(runtime: str) -> bool:
         return False
 
 
+def _saved_runtime_preference() -> str | None:
+    """Return the ``runtime_name`` saved by ``ndslive-setup``, if any.
+
+    ``ndslive-setup`` writes ``~/.nds/setup.json`` after a successful wizard
+    run. When the user has explicitly configured a runtime there, we honour
+    that choice ahead of environment-based detection so the two tools stay
+    in sync.
+    """
+    config_path = Path.home() / ".nds" / "setup.json"
+    if not config_path.exists():
+        return None
+    try:
+        with open(config_path) as f:
+            value = json.load(f).get("runtime_name")
+    except (json.JSONDecodeError, OSError):
+        return None
+    if value in ("docker", "podman"):
+        return value
+    return None
+
+
 @functools.lru_cache(maxsize=1)
 def detect_runtime() -> str:
     """Return the name of the container runtime to use.
 
     Resolution order:
 
-    1. ``CONTAINER_RUNTIME`` environment variable (``docker`` or ``podman``).
-    2. ``docker`` on ``$PATH``.
-    3. ``podman`` on ``$PATH``.
+    1. Saved ``runtime_name`` in ``~/.nds/setup.json`` (written by ``ndslive-setup``).
+    2. ``CONTAINER_RUNTIME`` environment variable (``docker`` or ``podman``).
+    3. ``docker`` on ``$PATH``.
+    4. ``podman`` on ``$PATH``.
 
     Raises :class:`FileNotFoundError` when no runtime is found.
     """
+    saved = _saved_runtime_preference()
+    if saved and _runtime_exists(saved):
+        return saved
+
     env = os.environ.get("CONTAINER_RUNTIME", "").strip().lower()
     if env in ("docker", "podman"):
         if _runtime_exists(env):
@@ -74,7 +100,8 @@ def detect_runtime() -> str:
         "No container runtime found.\n\n"
         "Please install Docker or Podman:\n"
         "  Docker: https://docs.docker.com/get-docker/\n"
-        "  Podman: https://podman.io/getting-started/installation"
+        "  Podman: https://podman.io/getting-started/installation\n\n"
+        "Tip: run 'ndslive-setup doctor' for a guided diagnosis."
     )
 
 
@@ -211,9 +238,13 @@ def get_auth_config_paths() -> list[Path]:
         ``~/.docker/config.json``
 
     Podman (checked in order):
-        ``$XDG_RUNTIME_DIR/containers/auth.json``
-        ``~/.config/containers/auth.json``
-        ``~/.docker/config.json``  (Podman reads this as fallback)
+        ``$XDG_RUNTIME_DIR/containers/auth.json``  (Linux session runtime dir)
+        ``~/.config/containers/auth.json``         (Linux / macOS default)
+        ``$APPDATA/containers/auth.json``          (Windows ``podman machine``)
+
+    Intentionally excludes ``~/.docker/config.json`` for podman: on macOS
+    Docker Desktop's ``credsStore`` helper runs on the host and podman
+    cannot invoke it, so a Docker login must not imply a Podman login.
     """
     rt = detect_runtime()
     paths: list[Path] = []
@@ -223,8 +254,9 @@ def get_auth_config_paths() -> list[Path]:
         if xdg:
             paths.append(Path(xdg) / "containers" / "auth.json")
         paths.append(Path.home() / ".config" / "containers" / "auth.json")
-        # Podman also honours Docker's config
-        paths.append(Path.home() / ".docker" / "config.json")
+        appdata = os.environ.get("APPDATA")
+        if appdata:
+            paths.append(Path(appdata) / "containers" / "auth.json")
     else:
         paths.append(Path.home() / ".docker" / "config.json")
 

{nds_mapviewer-2026.1.3.dev45 → nds_mapviewer-2026.1.3.dev47}/src/ndslive/mapviewer/docker_client.py

@@ -222,21 +222,48 @@ def is_logged_in(edition: str) -> bool:
         except (json.JSONDecodeError, OSError):
             continue
 
-        auths = config.get("auths", {})
-        for key in auths:
-            if registry_host in key or registry in key:
-                auth_data = auths[key]
-                if auth_data.get("auth") or auth_data.get("identitytoken"):
-                    return True
-
-        cred_helpers = config.get("credHelpers", {})
-        if any(registry_host in k for k in cred_helpers):
+        if _auth_config_contains(config, registry, registry_host):
             return True
 
-        # A global credsStore is not enough evidence on its own because it
-        # does not tell us whether this specific registry has credentials.
-        if config.get("credsStore"):
+    return False
+
+
+def _auth_config_contains(
+    config: dict, registry: str, registry_host: str,
+) -> bool:
+    """Return True if ``config`` has credentials for ``registry``.
+
+    A registry counts as present when:
+
+    * ``auths[key]`` has an ``auth`` or ``identitytoken`` value, or
+    * ``auths`` has an entry for ``key`` and the file declares a
+      ``credsStore`` (helper keeps the actual secret), or
+    * ``key`` appears in ``credHelpers`` (host or full registry path).
+
+    ``credsStore`` alone (no matching ``auths`` entry) is not enough —
+    it only says "some creds live in the helper", not that any exist
+    for this registry.
+    """
+    auths = config.get("auths", {}) or {}
+    creds_store = config.get("credsStore")
+    candidate_keys = (
+        registry_host,
+        f"https://{registry_host}",
+        registry,
+        f"https://{registry}",
+    )
+    for key in candidate_keys:
+        if key not in auths:
             continue
+        entry = auths.get(key) or {}
+        if entry.get("auth") or entry.get("identitytoken"):
+            return True
+        if creds_store:
+            return True
+
+    cred_helpers = config.get("credHelpers", {}) or {}
+    if any(key in cred_helpers for key in candidate_keys):
+        return True
 
     return False
 

{nds_mapviewer-2026.1.3.dev45 → nds_mapviewer-2026.1.3.dev47}/src/ndslive/mapviewer/exceptions.py

@@ -1,6 +1,12 @@
 """Custom exceptions for ndslive.mapviewer."""
 
 
+_DOCTOR_HINT = (
+    "Run 'ndslive-setup doctor' for a diagnosis, or 'ndslive-setup' to "
+    "reconfigure."
+)
+
+
 class MapViewerError(Exception):
     """Base exception for all MapViewer errors."""
 
@@ -16,7 +22,7 @@ class RuntimeNotInstalled(MapViewerError):
             "Please install Docker or Podman:\n"
             "  Docker:  https://docs.docker.com/get-docker/\n"
             "  Podman:  https://podman.io/getting-started/installation\n\n"
-            "After installation, run 'mapviewer setup' for guided setup."
+            f"{_DOCTOR_HINT}"
         )
         super().__init__(self.message)
 
@@ -34,8 +40,9 @@ class RuntimeNotRunning(MapViewerError):
             "Please start your container runtime:\n"
             "  Docker (macOS/Windows):  Open Docker Desktop\n"
             "  Docker (Linux):          sudo systemctl start docker\n"
+            "  Podman (macOS/Windows):  podman machine start\n"
             "  Podman (Linux):          systemctl --user start podman.socket\n\n"
-            "Run 'mapviewer setup' for guided setup."
+            f"{_DOCTOR_HINT}"
         )
         super().__init__(self.message)
 
@@ -65,7 +72,7 @@ class RegistryNotLoggedIn(MapViewerError):
             "  2. Click your username (top right) -> Edit Profile\n"
             "  3. Under Identity Tokens, click Generate\n"
             f"  4. Use the token as your password for {runtime} login\n\n"
-            "Run 'mapviewer setup' for guided setup."
+            f"{_DOCTOR_HINT}"
         )
         super().__init__(self.message)
 
@@ -150,6 +157,7 @@ class RegistryQueryFailed(MapViewerError):
             "\n\nPossible causes:"
             f"\n  - Not logged in: run '{runtime} login {registry}'"
             "\n  - Behind a proxy: configure your runtime's proxy settings"
+            f"\n\n{_DOCTOR_HINT}"
         )
         self.message = msg
         super().__init__(self.message)

{nds_mapviewer-2026.1.3.dev45 → nds_mapviewer-2026.1.3.dev47}/tests/test_docker_client.py

@@ -152,6 +152,88 @@ class TestIsLoggedIn:
 
         assert dc.is_logged_in("member") is True
 
+    def test_creds_store_with_auths_stub_returns_true(self, mocker, temp_dir):
+        """credsStore + an empty auths entry for the registry counts as logged in.
+
+        Docker CLI writes ``auths[host] = {}`` and stores the real secret in
+        the configured credential helper. The helper alone isn't proof (could
+        hold creds for any registry), but the combination is.
+        """
+        config_path = temp_dir / "config.json"
+        config_path.write_text(json.dumps({
+            "auths": {"artifactory.nds-association.org": {}},
+            "credsStore": "osxkeychain",
+        }))
+
+        mock_result = mocker.MagicMock(returncode=1, stdout="")
+        mocker.patch.object(rt, "run", return_value=mock_result)
+        mocker.patch.object(rt, "get_auth_config_paths", return_value=[config_path])
+
+        assert dc.is_logged_in("member") is True
+
+    def test_creds_store_without_registry_auths_returns_false(self, mocker, temp_dir):
+        """credsStore + auths for an unrelated registry does not count."""
+        config_path = temp_dir / "config.json"
+        config_path.write_text(json.dumps({
+            "auths": {"ghcr.io": {}},
+            "credsStore": "osxkeychain",
+        }))
+
+        mock_result = mocker.MagicMock(returncode=1, stdout="")
+        mocker.patch.object(rt, "run", return_value=mock_result)
+        mocker.patch.object(rt, "get_auth_config_paths", return_value=[config_path])
+
+        assert dc.is_logged_in("member") is False
+
+    def test_namespaced_auth_key_returns_true(self, mocker, temp_dir):
+        """Podman stores auth under the full namespaced key."""
+        config_path = temp_dir / "auth.json"
+        config_path.write_text(json.dumps({
+            "auths": {
+                "artifactory.nds-association.org/tooling-dockerreg": {
+                    "auth": "base64encoded",
+                },
+            },
+        }))
+
+        mock_result = mocker.MagicMock(returncode=1, stdout="")
+        mocker.patch.object(rt, "run", return_value=mock_result)
+        mocker.patch.object(rt, "get_auth_config_paths", return_value=[config_path])
+
+        assert dc.is_logged_in("member") is True
+
+    def test_scheme_prefixed_cred_helper_returns_true(self, mocker, temp_dir):
+        """``https://``-prefixed credHelpers keys are recognized."""
+        config_path = temp_dir / "config.json"
+        config_path.write_text(json.dumps({
+            "credHelpers": {
+                "https://artifactory.nds-association.org": "desktop",
+            },
+        }))
+
+        mock_result = mocker.MagicMock(returncode=1, stdout="")
+        mocker.patch.object(rt, "run", return_value=mock_result)
+        mocker.patch.object(rt, "get_auth_config_paths", return_value=[config_path])
+
+        assert dc.is_logged_in("member") is True
+
+    def test_https_prefixed_auths_key_returns_true(self, mocker, temp_dir):
+        """auths keys stored with an ``https://`` scheme prefix are recognized."""
+        config_path = temp_dir / "config.json"
+        config_path.write_text(json.dumps({
+            "auths": {
+                "https://artifactory.nds-association.org/tooling-dockerreg": {
+                    "auth": "base64encoded",
+                },
+            },
+        }))
+
+        mock_result = mocker.MagicMock(returncode=1, stdout="")
+        mocker.patch.object(rt, "run", return_value=mock_result)
+        mocker.patch.object(rt, "get_auth_config_paths", return_value=[config_path])
+
+        assert dc.is_logged_in("member") is True
+
 
 class TestListContainers:
     """Tests for list_containers()."""
@@ -354,9 +436,10 @@ class TestContainerRuntime:
         runtime = rt.detect_runtime()
         assert runtime in ("docker", "podman")
 
-    def test_detect_runtime_prefers_working_runtime(self, mocker):
+    def test_detect_runtime_prefers_working_runtime(self, tmp_path, mocker, monkeypatch):
         """Auto-detection should skip an installed but unhealthy runtime."""
         rt.detect_runtime.cache_clear()
+        monkeypatch.setattr(rt.Path, "home", lambda: tmp_path)
         mocker.patch.dict(os.environ, {"CONTAINER_RUNTIME": ""}, clear=False)
         mocker.patch.object(rt.shutil, "which", side_effect=lambda name: f"/usr/bin/{name}")
 
@@ -375,9 +458,10 @@ class TestContainerRuntime:
         finally:
             rt.detect_runtime.cache_clear()
 
-    def test_detect_runtime_explicit_env_forces_choice(self, mocker):
+    def test_detect_runtime_explicit_env_forces_choice(self, tmp_path, mocker, monkeypatch):
         """CONTAINER_RUNTIME should force the selected runtime."""
         rt.detect_runtime.cache_clear()
+        monkeypatch.setattr(rt.Path, "home", lambda: tmp_path)
         mocker.patch.dict(os.environ, {"CONTAINER_RUNTIME": "docker"}, clear=False)
         mocker.patch.object(rt.shutil, "which", side_effect=lambda name: f"/usr/bin/{name}")
         mocker.patch.object(rt.subprocess, "run", side_effect=AssertionError("should not probe"))
@@ -386,9 +470,12 @@ class TestContainerRuntime:
         finally:
             rt.detect_runtime.cache_clear()
 
-    def test_detect_runtime_returns_first_installed_if_none_respond(self, mocker):
+    def test_detect_runtime_returns_first_installed_if_none_respond(
+        self, tmp_path, mocker, monkeypatch,
+    ):
         """When no runtime is responsive, keep the first installed for later errors."""
         rt.detect_runtime.cache_clear()
+        monkeypatch.setattr(rt.Path, "home", lambda: tmp_path)
         mocker.patch.dict(os.environ, {"CONTAINER_RUNTIME": ""}, clear=False)
         mocker.patch.object(rt.shutil, "which", side_effect=lambda name: f"/usr/bin/{name}")
         mocker.patch.object(
@@ -416,6 +503,144 @@ class TestContainerRuntime:
         assert isinstance(paths, list)
         assert all(isinstance(p, type(paths[0])) for p in paths)
 
+    def test_detect_runtime_honours_setup_json(self, tmp_path, mocker, monkeypatch):
+        """A runtime_name in ~/.nds/setup.json wins over env/autodetect."""
+        rt.detect_runtime.cache_clear()
+        setup_dir = tmp_path / ".nds"
+        setup_dir.mkdir()
+        (setup_dir / "setup.json").write_text(json.dumps({"runtime_name": "podman"}))
+
+        monkeypatch.setattr(rt.Path, "home", lambda: tmp_path)
+        monkeypatch.setenv("CONTAINER_RUNTIME", "docker")
+        mocker.patch.object(rt.shutil, "which", side_effect=lambda name: f"/usr/bin/{name}")
+        mocker.patch.object(
+            rt.subprocess,
+            "run",
+            side_effect=AssertionError("should not probe when saved pref wins"),
+        )
+        try:
+            assert rt.detect_runtime() == "podman"
+        finally:
+            rt.detect_runtime.cache_clear()
+
+    def test_detect_runtime_falls_back_when_saved_missing(
+        self, tmp_path, mocker, monkeypatch,
+    ):
+        """If the saved runtime isn't on PATH, fall back to env/autodetect."""
+        rt.detect_runtime.cache_clear()
+        setup_dir = tmp_path / ".nds"
+        setup_dir.mkdir()
+        (setup_dir / "setup.json").write_text(json.dumps({"runtime_name": "podman"}))
+
+        monkeypatch.setattr(rt.Path, "home", lambda: tmp_path)
+        monkeypatch.delenv("CONTAINER_RUNTIME", raising=False)
+        mocker.patch.object(
+            rt.shutil,
+            "which",
+            side_effect=lambda name: "/usr/bin/docker" if name == "docker" else None,
+        )
+        mocker.patch.object(
+            rt.subprocess,
+            "run",
+            return_value=subprocess.CompletedProcess(["docker", "info"], 0, "", ""),
+        )
+        try:
+            assert rt.detect_runtime() == "docker"
+        finally:
+            rt.detect_runtime.cache_clear()
+
+    def test_detect_runtime_ignores_malformed_setup_json(
+        self, tmp_path, mocker, monkeypatch,
+    ):
+        """Garbled ~/.nds/setup.json must not break detection."""
+        rt.detect_runtime.cache_clear()
+        setup_dir = tmp_path / ".nds"
+        setup_dir.mkdir()
+        (setup_dir / "setup.json").write_text("{ not valid json")
+
+        monkeypatch.setattr(rt.Path, "home", lambda: tmp_path)
+        monkeypatch.delenv("CONTAINER_RUNTIME", raising=False)
+        mocker.patch.object(
+            rt.shutil,
+            "which",
+            side_effect=lambda name: "/usr/bin/docker" if name == "docker" else None,
+        )
+        mocker.patch.object(
+            rt.subprocess,
+            "run",
+            return_value=subprocess.CompletedProcess(["docker", "info"], 0, "", ""),
+        )
+        try:
+            assert rt.detect_runtime() == "docker"
+        finally:
+            rt.detect_runtime.cache_clear()
+
+    def test_detect_runtime_ignores_unknown_runtime_name(
+        self, tmp_path, mocker, monkeypatch,
+    ):
+        """An unrecognised runtime_name in setup.json is ignored, not rejected."""
+        rt.detect_runtime.cache_clear()
+        setup_dir = tmp_path / ".nds"
+        setup_dir.mkdir()
+        (setup_dir / "setup.json").write_text(json.dumps({"runtime_name": "rkt"}))
+
+        monkeypatch.setattr(rt.Path, "home", lambda: tmp_path)
+        monkeypatch.delenv("CONTAINER_RUNTIME", raising=False)
+        mocker.patch.object(
+            rt.shutil,
+            "which",
+            side_effect=lambda name: "/usr/bin/docker" if name == "docker" else None,
+        )
+        mocker.patch.object(
+            rt.subprocess,
+            "run",
+            return_value=subprocess.CompletedProcess(["docker", "info"], 0, "", ""),
+        )
+        try:
+            assert rt.detect_runtime() == "docker"
+        finally:
+            rt.detect_runtime.cache_clear()
+
+    def test_podman_auth_paths_exclude_docker_config(self, monkeypatch):
+        """Podman should not consider ~/.docker/config.json as a login source.
+
+        On macOS, Docker Desktop's credsStore runs on the host and podman
+        cannot invoke it — so a docker login must not imply a podman login.
+        """
+        rt.detect_runtime.cache_clear()
+        monkeypatch.setenv("CONTAINER_RUNTIME", "podman")
+        monkeypatch.delenv("XDG_RUNTIME_DIR", raising=False)
+        monkeypatch.delenv("APPDATA", raising=False)
+        # shutil.which needs to find podman for detect_runtime to accept env.
+        import shutil as _sh
+        monkeypatch.setattr(
+            rt.shutil, "which",
+            lambda name: "/usr/bin/podman" if name == "podman" else None,
+        )
+        try:
+            paths = rt.get_auth_config_paths()
+            docker_config = rt.Path.home() / ".docker" / "config.json"
+            assert docker_config not in paths
+        finally:
+            rt.detect_runtime.cache_clear()
+
+    def test_podman_auth_paths_include_appdata_on_windows(self, tmp_path, monkeypatch):
+        """When APPDATA is set (Windows), podman auth.json under it is probed."""
+        rt.detect_runtime.cache_clear()
+        monkeypatch.setenv("CONTAINER_RUNTIME", "podman")
+        monkeypatch.setenv("APPDATA", str(tmp_path / "AppData" / "Roaming"))
+        monkeypatch.delenv("XDG_RUNTIME_DIR", raising=False)
+        monkeypatch.setattr(
+            rt.shutil, "which",
+            lambda name: "/usr/bin/podman" if name == "podman" else None,
+        )
+        try:
+            paths = rt.get_auth_config_paths()
+            expected = rt.Path(str(tmp_path / "AppData" / "Roaming")) / "containers" / "auth.json"
+            assert expected in paths
+        finally:
+            rt.detect_runtime.cache_clear()
+
     def test_parse_size_string(self):
         """Parse common size format strings."""
         assert rt.parse_size_string("256MiB") == 256 * 1024 * 1024