netbox-super-cli 1.6.2__tar.gz → 1.7.0__tar.gz

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/.github/workflows/docs.yml

@@ -36,7 +36,7 @@ jobs:
       - name: Sync deps (runtime + docs)
         run: uv sync --frozen --group docs
       - name: Build site (strict)
-        run: uv run mkdocs build --strict
+        run: uv run zensical build --strict
       - name: Upload Pages artifact
         if: github.ref_type == 'tag'
         uses: actions/upload-pages-artifact@v5

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/.gitignore

@@ -33,7 +33,7 @@ venv/
 # Local-only design notes (kept out of git history)
 docs/superpowers/
 
-# mkdocs
+# docs build output
 site/
 
 # git worktrees

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/.pre-commit-config.yaml

@@ -27,7 +27,7 @@ repos:
           - click>=8.1
           - typer>=0.12
           - rich>=13.7
-          - httpx>=0.27
+          - httpx2>=2.5
           - "ruamel.yaml>=0.18"
           - structlog>=24.1
           - platformdirs>=4.2

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/AGENTS.md

@@ -15,7 +15,7 @@ This is the contributor guide for AI agents (and humans!) modifying this repo. T
 - `nsc/model/` — the normalized command tree (data only, framework-free). The "brain".
 - `nsc/builder/` — converts a parsed schema into a `CommandModel`.
 - `nsc/cli/` — the Typer app; consumes a `CommandModel`.
-- `nsc/http/` — thin httpx wrapper: auth, retries, audit log.
+- `nsc/http/` — thin httpx2 wrapper: auth, retries, audit log.
 - `nsc/output/` — formatters (table/json/jsonl/yaml/csv) + error envelope.
 - `nsc/config/` — config loader + Pydantic models + ruamel.yaml round-trip writer.
 - `nsc/cache/` — disk cache for generated command-models.

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/CHANGELOG.md

@@ -2,6 +2,56 @@
 
 All notable changes to netbox-super-cli are tracked here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) loosely. From v1.0.0 onward, releases follow [Semantic Versioning](https://semver.org/) and the version in `pyproject.toml` matches the git tag. Pre-1.0 milestones (Phase 1-5) were pinned by tag while `pyproject.toml` stayed at `0.0.1`.
 
+## v1.7.0 — 2026-09-10
+
+Minor release. Migrates the HTTP stack from `httpx` to Pydantic's maintained
+`httpx2` fork, and keeps `httpx2` off the `nsc --help` cold-start path. No
+user-facing CLI or behavior changes.
+
+### Changed
+
+- **Migrated the HTTP stack from `httpx` to `httpx2`** ([#146]). `httpx2` is
+  Pydantic's stewardship continuation of httpx (same author, API-identical) —
+  httpx itself has seen limited activity, and httpx2 is the reliably-maintained
+  path forward with timely security updates. The dependency floor is now
+  `httpx2>=2.5`; the source layer is a mechanical rename (`import httpx2`,
+  `httpx2.Client`/`httpx2.Response`/…). Test mocking moves from global `respx`
+  to the `pytest-httpx2` plugin's `httpx2_mock` fixture (a `respx.Router`, by
+  respx's own author), which targets httpx2's `httpcore2` transport. No
+  user-facing behavior or CLI surface changes.
+- **httpx2 is now kept off the `nsc --help` / cold-start path** ([#13]). httpx2 is
+  the single heaviest import in the tree (~65ms cold), and nothing on the startup
+  path needs an HTTP client. It was being pulled in eagerly through the
+  runtime → client → retry chain (plus `cache`, `schema`, and `login`
+  command modules). All of these now import httpx2 lazily, at first request. Cold
+  startup drops by roughly httpx2's import cost, bringing the median back under the
+  300ms project target. A new guard test (`test_lazy_httpx2_import.py`) asserts
+  httpx2 never loads on `nsc --help`, and the startup benchmark's threshold is
+  re-baselined to 300ms so an over-threshold skip once again signals a real
+  regression instead of firing on every run.
+
+[#13]: https://github.com/thomaschristory/netbox-super-cli/issues/13
+[#146]: https://github.com/thomaschristory/netbox-super-cli/issues/146
+
+## v1.6.3 — 2026-07-03
+
+Patch release. Stops an offline instance from rebuilding the command model from
+the bundled schema on every invocation after a format-version bump.
+
+### Fixed
+
+- **Offline invocations rebuilt from the bundled schema every time when the only
+  cached model was format-stale** ([#140]). After the v1.6.2 format-version bump
+  (#139), a cache entry built by an older `nsc` is rejected so it rebuilds with
+  the new metadata. Online this self-heals on the first call, but while NetBox
+  was unreachable nothing re-saved: each invocation re-parsed the bundled schema
+  (~180ms) and tab-completion went briefly blank for the profile. The offline
+  bundled fallback is now persisted under the profile — without a fetch
+  timestamp, so the TTL fast-path still refetches once NetBox is reachable — so
+  the next invocation hits the cache and completion recovers immediately.
+
+[#140]: https://github.com/thomaschristory/netbox-super-cli/issues/140
+
 ## v1.6.2 — 2026-06-30
 
 Patch release. Fixes TUI foreign-key pickers resolving to the wrong resource.

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/CLAUDE.md

@@ -8,7 +8,7 @@ This is the contributor guide for AI agents (and humans!) modifying this repo. T
 - `nsc/model/` — the normalized command tree (data only, framework-free). The "brain".
 - `nsc/builder/` — converts a parsed schema into a `CommandModel`.
 - `nsc/cli/` — the Typer app; consumes a `CommandModel`.
-- `nsc/http/` — thin httpx wrapper: auth, retries, audit log.
+- `nsc/http/` — thin httpx2 wrapper: auth, retries, audit log.
 - `nsc/output/` — formatters (table/json/jsonl/yaml/csv) + error envelope.
 - `nsc/config/` — config loader + Pydantic models + ruamel.yaml round-trip writer.
 - `nsc/cache/` — disk cache for generated command-models.

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: netbox-super-cli
-Version: 1.6.2
+Version: 1.7.0
 Summary: Dynamic NetBox CLI generated from the live OpenAPI schema.
 Project-URL: Homepage, https://github.com/thomaschristory/netbox-super-cli
 Project-URL: Documentation, https://thomaschristory.github.io/netbox-super-cli/
@@ -23,7 +23,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: System :: Networking
 Requires-Python: >=3.12
 Requires-Dist: click>=8.1
-Requires-Dist: httpx>=0.27
+Requires-Dist: httpx2>=2.5
 Requires-Dist: platformdirs>=4.2
 Requires-Dist: pydantic>=2.7
 Requires-Dist: rich>=13.7

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/docs/architecture/http-client.md

@@ -1,6 +1,6 @@
 # HTTP client
 
-`nsc/http/` is a thin wrapper around `httpx.Client`.
+`nsc/http/` is a thin wrapper around `httpx2.Client`.
 
 ## What it adds
 
@@ -27,7 +27,7 @@
 
 Bulk write commands accept `--workers N` (default 1, max 32) to keep up to N
 requests in flight. Concurrency is **thread-based**: a `ThreadPoolExecutor`
-fans the per-record loop out over the single sync `httpx.Client` — there is no
+fans the per-record loop out over the single sync `httpx2.Client` — there is no
 async path. Per-record `--on-error` semantics are preserved regardless of
 worker count. Audit appends are serialized by a module-level lock
 (`_APPEND_LOCK` in `nsc/http/audit.py`) wrapped around the whole
@@ -40,9 +40,9 @@ each record is one well-formed JSON line.
 
 A schema fetch may run before the first command request (only when the
 TTL fast-path misses — see [Caching](caching.md)); it uses its own
-short-lived `httpx.Client` in `nsc/schema/`, not this `NetBoxClient`.
+short-lived `httpx2.Client` in `nsc/schema/`, not this `NetBoxClient`.
 Command requests then go through a single `NetBoxClient` whose
-`httpx.Client` carries the auth header for the life of the process.
+`httpx2.Client` carries the auth header for the life of the process.
 Token rotation via `nsc login --rotate` does NOT invalidate the cached
 model (the schema hash is what keys the cache; the token never affected
 it).
@@ -91,7 +91,7 @@ contract.
 
 ## What it deliberately does not do
 
-- Async — sync only in v1, kept feasible by httpx if a future async path lands.
+- Async — sync only in v1, kept feasible by httpx2 if a future async path lands.
 - Connection pooling across profiles — each profile gets its own `Client`.
 - Caching responses — caching the command-model is enough; caching response
   payloads would surprise users.

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/docs/architecture/overview.md

@@ -1,7 +1,7 @@
 # Architecture overview
 
 `nsc` is layered around a framework-free "brain". The brain — schema parsing
-and the normalized command-model — knows nothing about Typer, Rich, or httpx.
+and the normalized command-model — knows nothing about Typer, Rich, or httpx2.
 The CLI layer consumes the brain; a future TUI could too without changing the
 brain.
 
@@ -11,7 +11,7 @@ nsc/
 ├── model/           # Normalized command-model (data only, framework-free)
 ├── builder/         # Schema → CommandModel
 ├── cli/             # Typer application; walks the model, registers commands
-├── http/            # Thin httpx wrapper: auth, retries, audit
+├── http/            # Thin httpx2 wrapper: auth, retries, audit
 ├── output/          # Formatters (table/json/jsonl/yaml/csv) + error envelope
 ├── config/          # Pydantic config models + ruamel.yaml writer
 ├── cache/           # On-disk cache for generated CommandModels

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/docs/contributing/release-process.md

@@ -11,7 +11,7 @@ on a `chore/release-X.Y.Z` feature branch, gets PR-merged into `main`,
 and only then is `vX.Y.Z` tagged on the resulting merge commit.
 
 The same `v*` tag push also publishes the documentation site.
-`docs.yml` runs build-only (`mkdocs build --strict`) on docs-touching
+`docs.yml` runs build-only (`zensical build --strict`) on docs-touching
 pull requests, but the GitHub Pages **deploy** job only runs on a `v*`
 tag push — the live docs site updates on release, not on merge to
 `main`.

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/justfile

@@ -54,10 +54,10 @@ e2e:
         docker compose -f tests/e2e/docker-compose.yml down -v; \
         exit $rc
 
-# Serve the MkDocs site locally at http://127.0.0.1:8000
+# Serve the docs site locally at http://127.0.0.1:8000 (preview only)
 docs:
-    uv run mkdocs serve
+    uv run zensical serve
 
-# Build the MkDocs site (strict mode — fails on broken links, missing nav targets, etc.)
+# Build the docs site (strict mode — fails on broken links, missing anchors, etc.)
 docs-build:
-    uv run mkdocs build --strict
+    uv run zensical build --strict

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/nsc/_version.py

@@ -1,3 +1,3 @@
 """Single source of truth for the package version."""
 
-__version__ = "1.6.2"
+__version__ = "1.7.0"

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/nsc/auth/verify.py

@@ -17,11 +17,15 @@ out of `audit.jsonl`. There is no retry loop: a single failed probe fails fast.
 
 from __future__ import annotations
 
-import httpx
+from typing import TYPE_CHECKING
+
 from pydantic import BaseModel, ConfigDict
 
 from nsc.config.models import Profile
 
+if TYPE_CHECKING:
+    import httpx2
+
 _DEFAULT_TIMEOUT = 10.0
 
 
@@ -65,6 +69,8 @@ def verify(profile: Profile, *, timeout: float = _DEFAULT_TIMEOUT) -> VerifyResu
 
     Raises `VerifyError` on any failure. Returns a `VerifyResult` on success.
     """
+    import httpx2  # noqa: PLC0415  # deferred: keeps httpx2 off the CLI-startup path.
+
     if not profile.token:
         raise VerifyError(message="profile has no token; cannot verify")
     base = str(profile.url).rstrip("/")
@@ -72,7 +78,7 @@ def verify(profile: Profile, *, timeout: float = _DEFAULT_TIMEOUT) -> VerifyResu
         "Authorization": f"Token {profile.token}",
         "Accept": "application/json",
     }
-    with httpx.Client(
+    with httpx2.Client(
         base_url=base,
         headers=headers,
         verify=profile.verify_ssl,
@@ -83,10 +89,12 @@ def verify(profile: Profile, *, timeout: float = _DEFAULT_TIMEOUT) -> VerifyResu
     return VerifyResult(username=username, netbox_version=version)
 
 
-def _probe_status(client: httpx.Client) -> str:
+def _probe_status(client: httpx2.Client) -> str:
+    import httpx2  # noqa: PLC0415  # deferred: keeps httpx2 off the CLI-startup path.
+
     try:
         response = client.get("/api/status/")
-    except (httpx.RequestError, OSError) as exc:
+    except (httpx2.RequestError, OSError) as exc:
         raise VerifyError(message=f"could not reach NetBox: {exc}") from exc
     if not response.is_success:
         raise VerifyError(
@@ -98,7 +106,7 @@ def _probe_status(client: httpx.Client) -> str:
     return str(version) if version else "unknown"
 
 
-def _probe_users_me(client: httpx.Client) -> str:
+def _probe_users_me(client: httpx2.Client) -> str:
     """Verify the token via `GET /api/users/tokens/?limit=1`.
 
     NetBox does not expose a top-level "current user" endpoint (`/api/users/me/`
@@ -109,9 +117,11 @@ def _probe_users_me(client: httpx.Client) -> str:
     calling user's identity in the common case. If the user has no visible
     tokens (an unusual admin state), we surface "(unknown)" rather than failing.
     """
+    import httpx2  # noqa: PLC0415  # deferred: keeps httpx2 off the CLI-startup path.
+
     try:
         response = client.get("/api/users/tokens/", params={"limit": 1})
-    except (httpx.RequestError, OSError) as exc:
+    except (httpx2.RequestError, OSError) as exc:
         raise VerifyError(message=f"token probe failed: {exc}") from exc
     if not response.is_success:
         raise VerifyError(
@@ -136,7 +146,7 @@ def _probe_users_me(client: httpx.Client) -> str:
     return "(unknown)"
 
 
-def _safe_json(response: httpx.Response) -> object:
+def _safe_json(response: httpx2.Response) -> object:
     try:
         return response.json()
     except ValueError:

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/nsc/cache/store.py

@@ -82,13 +82,21 @@ class CacheStore:
             return None
         return model
 
-    def save(self, profile: str, model: CommandModel) -> Path:
+    def save(self, profile: str, model: CommandModel, *, record_fetch: bool = True) -> Path:
+        """Persist `model` under the profile. `record_fetch=True` also stamps
+        the `fetched_at` sidecar (a live fetch just produced this model, so
+        the TTL fast-path may trust it). Pass `record_fetch=False` for models
+        that were *not* fetched from this NetBox — e.g. the offline bundled
+        fallback (issue #140): we want the persisted copy so future offline
+        invocations skip the rebuild, but the TTL fast-path must keep
+        distrusting it so a real fetch is attempted once NetBox is reachable."""
         self._validate_profile(profile)
         target = self._path_for(profile, model.schema_hash)
         target.parent.mkdir(parents=True, exist_ok=True)
         _atomic_write(target, model.model_dump_json(indent=2))
-        meta = self._meta_path_for(profile, model.schema_hash)
-        _atomic_write(meta, json.dumps({"fetched_at": time.time()}))
+        if record_fetch:
+            meta = self._meta_path_for(profile, model.schema_hash)
+            _atomic_write(meta, json.dumps({"fetched_at": time.time()}))
         return target
 
     def touch_fetched_at(self, profile: str, schema_hash: str) -> None:

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/nsc/cli/cache_commands.py

@@ -7,7 +7,6 @@ from collections.abc import Callable
 from enum import StrEnum
 from typing import Annotated
 
-import httpx
 import typer
 
 from nsc.cache.store import (
@@ -45,12 +44,14 @@ def _load_config_or_empty() -> Config:
 
 
 def _fetch_live_hash(profile: Profile, *, default_timeout: float) -> str:
+    import httpx2  # noqa: PLC0415  # deferred: keeps httpx2 off the CLI-startup path.
+
     url = str(profile.url).rstrip("/") + "/api/schema/?format=json"
     headers = {"Accept": "application/json"}
     if profile.token:
         headers["Authorization"] = f"Token {profile.token}"
     timeout = profile.timeout if profile.timeout is not None else default_timeout
-    with httpx.Client(verify=profile.verify_ssl, timeout=timeout, headers=headers) as c:
+    with httpx2.Client(verify=profile.verify_ssl, timeout=timeout, headers=headers) as c:
         resp = c.get(url)
         resp.raise_for_status()
         return canonical_sha256(resp.content)

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/nsc/cli/runtime.py

@@ -206,7 +206,7 @@ def resolve_object_colors(mode: ObjectColorMode, *, color: bool) -> bool:
 class RuntimeContext(BaseModel):
     """Per-invocation runtime state.
 
-    Not frozen because `client` (a NetBoxClient wrapping httpx.Client) is mutable.
+    Not frozen because `client` (a NetBoxClient wrapping httpx2.Client) is mutable.
     """
 
     model_config = ConfigDict(arbitrary_types_allowed=True, extra="forbid")

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/nsc/cli/writes/bulk.py

@@ -1,6 +1,6 @@
 """Bulk routing brain (Phase 3c).
 
-Pure logic. No I/O, no Typer, no httpx. Three responsibilities:
+Pure logic. No I/O, no Typer, no httpx2. Three responsibilities:
 
 1. `detect_bulk_capability(operation)` — classify a parsed Operation as
    bulk-capable, single-only, or ambiguous (spec §4.5).
@@ -195,7 +195,7 @@ def run_loop(
     With `workers == 1` the loop is sequential and deterministic: requests run
     in input order and audit fires once per attempted request in that order.
     With `workers > 1` up to `workers` requests are in flight concurrently via
-    a thread pool (the NetBox client is sync httpx, so threads — not asyncio —
+    a thread pool (the NetBox client is sync httpx2, so threads — not asyncio —
     are the right mechanism). Each record's send/retry/audit is independent.
 
     On `on_error="stop"` the loop stops submitting *new* work after the first
@@ -211,7 +211,7 @@ def run_loop(
 
     `send_one` does the wire send; `audit_attempt` writes the audit entry;
     `to_envelope` converts a raised exception into an ErrorEnvelope. Callers
-    inject these so this loop has no dependency on httpx or the audit module.
+    inject these so this loop has no dependency on httpx2 or the audit module.
     """
     if workers < 1:
         raise ValueError(f"workers must be >= 1, got {workers}")

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/nsc/completion/cache_probe.py

@@ -1,7 +1,7 @@
 """Cheap on-disk reads for completion.
 
 This module deliberately avoids importing `nsc.schema.source` (which pulls in
-httpx and the schema-build pipeline). It reads the cached `CommandModel`
+httpx2 and the schema-build pipeline). It reads the cached `CommandModel`
 JSON directly via `CacheStore`, which validates the file but performs no
 network I/O. Picking the newest cache file for a profile means we never need
 the live schema hash at TAB time.

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/nsc/completion/callbacks.py

@@ -10,7 +10,7 @@ the `#82` note in `nsc/cli/app.py`).
 Every public function swallows exceptions and degrades to `[]`: a raised
 exception during completion would corrupt the user's shell prompt.
 
-Imports are kept lazy/cheap — no `nsc.cli`, no httpx — so loading this module
+Imports are kept lazy/cheap — no `nsc.cli`, no httpx2 — so loading this module
 never drags in the full app cold-start path.
 """
 

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/nsc/http/audit.py

@@ -129,7 +129,7 @@ def _sanitize_url(url: str) -> str:
 
     The query string of a debug-mode GET can carry secret filter values
     (e.g. `?private_key=...`), and `Profile.url` permits `https://user:pass@host`
-    whose `user:pass@` httpx keeps in `str(request.url)`. Both are stripped so a
+    whose `user:pass@` httpx2 keeps in `str(request.url)`. Both are stripped so a
     `full` line cannot leak a credential through the one remaining string field.
 
     Robust to URLs with no query/userinfo (no-op) and to relative/edge URLs: if

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/nsc/http/client.py

@@ -1,4 +1,4 @@
-"""Sync httpx-based NetBox client."""
+"""Sync httpx2-based NetBox client."""
 
 from __future__ import annotations
 
@@ -7,11 +7,9 @@ import time
 from collections.abc import Iterator
 from datetime import UTC, datetime
 from types import TracebackType
-from typing import Any, Protocol, cast
+from typing import TYPE_CHECKING, Any, Protocol, cast
 from urllib.parse import parse_qs, urlsplit
 
-import httpx
-
 from nsc.config.models import AuditRedaction
 from nsc.config.settings import default_paths
 from nsc.http.audit import (
@@ -29,6 +27,9 @@ from nsc.http.retry import (
 )
 from nsc.model.command_model import HttpMethod
 
+if TYPE_CHECKING:
+    import httpx2
+
 _BODY_SNIPPET_BYTES = 2048
 _HTTP_5XX_MIN = 500
 _HTTP_4XX_MIN = 400
@@ -50,13 +51,15 @@ class NetBoxClient:
         redaction: AuditRedaction = AuditRedaction.SAFE,
         profile_name: str | None = None,
     ) -> None:
+        import httpx2  # noqa: PLC0415  # deferred: keeps httpx2 off the CLI-startup path.
+
         if profile.token is None:
             raise ValueError("NetBoxClient requires a non-None token on the profile")
         self._url = str(profile.url).rstrip("/")
         self._debug = debug
         self._redaction = redaction
         self._profile_name = profile_name
-        self._client = httpx.Client(
+        self._client = httpx2.Client(
             base_url=self._url,
             headers={
                 "Authorization": f"Token {profile.token}",
@@ -173,7 +176,7 @@ class NetBoxClient:
             if first:
                 req_path, req_params = url, params
             else:
-                # next URLs are absolute; split them so respx (and httpx) can
+                # next URLs are absolute; split them so respx (and httpx2) can
                 # match on path + params independently rather than a raw string.
                 parsed = urlsplit(url)
                 req_path = parsed.path
@@ -199,7 +202,9 @@ class NetBoxClient:
         operation_id: str | None = None,
         record_indices: list[int] | None = None,
         sensitive_paths: tuple[str, ...] = (),
-    ) -> httpx.Response:
+    ) -> httpx2.Response:
+        import httpx2  # noqa: PLC0415  # deferred: keeps httpx2 off the CLI-startup path.
+
         policy = policy_for_method(method)
         attempt = 0
         is_write = method not in {HttpMethod.GET, HttpMethod.HEAD, HttpMethod.OPTIONS}
@@ -209,7 +214,7 @@ class NetBoxClient:
             started = time.monotonic()
             try:
                 response = self._client.request(method.value, path, params=params, json=json_body)
-            except httpx.RequestError as exc:
+            except httpx2.RequestError as exc:
                 error_class: ErrorClass = classify_error(exc)
                 duration_ms = int((time.monotonic() - started) * 1000)
                 retry = should_retry(
@@ -264,7 +269,7 @@ class NetBoxClient:
         request = self._client.build_request("GET", path, params=params)
         return str(request.url)
 
-    def _raise_for_status(self, response: httpx.Response) -> None:
+    def _raise_for_status(self, response: httpx2.Response) -> None:
         try:
             body = response.text[:_BODY_SNIPPET_BYTES]
         except Exception:  # pragma: no cover
@@ -283,7 +288,7 @@ class NetBoxClient:
         path: str,
         params: dict[str, Any] | None,
         request_body: Any | None,
-        response: httpx.Response | None,
+        response: httpx2.Response | None,
         duration_ms: int,
         attempt: int,
         final: bool,
@@ -293,7 +298,7 @@ class NetBoxClient:
         sensitive_paths: tuple[str, ...] = (),
     ) -> None:
         url = self._absolute(path, params)
-        # httpx lowercases all header names; title-case them so the audit log
+        # httpx2 lowercases all header names; title-case them so the audit log
         # uses the conventional HTTP capitalisation (e.g. "Authorization").
         request_headers = {k.title(): v for k, v in self._client.headers.items()}
         if response is not None:
@@ -346,13 +351,13 @@ class NetBoxClient:
             append_audit_jsonl(entry, path=log_dir / "audit.jsonl")
 
     def _event_hooks(self) -> dict[str, list[Any]]:
-        def on_request(request: httpx.Request) -> None:
+        def on_request(request: httpx2.Request) -> None:
             print(f">>> {request.method} {request.url}", file=sys.stderr)
             for k, v in request.headers.items():
                 masked = "<redacted>" if k.lower() == "authorization" else v
                 print(f">>> {k}: {masked}", file=sys.stderr)
 
-        def on_response(response: httpx.Response) -> None:
+        def on_response(response: httpx2.Response) -> None:
             response.read()
             print(f"<<< {response.status_code} {response.reason_phrase}", file=sys.stderr)
             for k, v in response.headers.items():
@@ -368,7 +373,7 @@ def _now_iso() -> str:
     return datetime.now(UTC).isoformat(timespec="milliseconds").replace("+00:00", "Z")
 
 
-def _parse_json(response: httpx.Response) -> dict[str, Any]:
+def _parse_json(response: httpx2.Response) -> dict[str, Any]:
     if not response.content:
         return {}
     return cast(dict[str, Any], response.json())

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/nsc/http/retry.py

@@ -9,7 +9,6 @@ from __future__ import annotations
 import random
 from enum import Enum
 
-import httpx
 from pydantic import BaseModel, ConfigDict
 
 from nsc.model.command_model import HttpMethod
@@ -48,10 +47,12 @@ def policy_for_method(method: HttpMethod) -> RetryPolicy:
 
 
 def classify_error(exc: BaseException) -> ErrorClass:
-    """Map an httpx transport exception to a retry-relevant class."""
-    if isinstance(exc, (httpx.ConnectError, httpx.ConnectTimeout)):
+    """Map an httpx2 transport exception to a retry-relevant class."""
+    import httpx2  # noqa: PLC0415  # deferred: keeps httpx2 off the CLI-startup path.
+
+    if isinstance(exc, (httpx2.ConnectError, httpx2.ConnectTimeout)):
         return ErrorClass.CONNECT
-    if isinstance(exc, httpx.ReadTimeout):
+    if isinstance(exc, httpx2.ReadTimeout):
         return ErrorClass.READ_TIMEOUT
     return ErrorClass.TRANSPORT_AMBIGUOUS
 

{netbox_super_cli-1.6.2 → netbox_super_cli-1.7.0}/nsc/schema/loader.py

@@ -7,8 +7,6 @@ from collections.abc import Iterator
 from dataclasses import dataclass
 from pathlib import Path
 
-import httpx
-
 from nsc.schema.hashing import canonical_sha256
 from nsc.schema.models import OpenAPIDocument
 
@@ -122,8 +120,10 @@ def _decode_content_encoding(raw: bytes, encoding: str, source: str) -> bytes:
 
 
 def _fetch_http_body(source: str, *, verify_ssl: bool, timeout: float) -> bytes:
+    import httpx2  # noqa: PLC0415  # deferred: keeps httpx2 off the CLI-startup path.
+
     try:
-        with httpx.stream(
+        with httpx2.stream(
             "GET",
             source,
             verify=verify_ssl,
@@ -139,5 +139,5 @@ def _fetch_http_body(source: str, *, verify_ssl: bool, timeout: float) -> bytes:
             raw = _read_capped(response.iter_raw(), source)
             encoding = response.headers.get("content-encoding", "")
             return _decode_content_encoding(raw, encoding, source)
-    except httpx.HTTPError as exc:
+    except httpx2.HTTPError as exc:
         raise SchemaLoadError(f"{source}: request failed ({exc})") from exc