mkdocs2confluence 0.7.23__tar.gz → 0.7.25__tar.gz

{mkdocs2confluence-0.7.23 → mkdocs2confluence-0.7.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs2confluence
-Version: 0.7.23
+Version: 0.7.25
 Summary: Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more
 Author: Anders Hybertz
 License: GPL-3.0-or-later

{mkdocs2confluence-0.7.23 → mkdocs2confluence-0.7.25}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mkdocs2confluence"
-version = "0.7.23"
+version = "0.7.25"
 description = "Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more"
 readme = "README.md"
 license = { text = "GPL-3.0-or-later" }

{mkdocs2confluence-0.7.23 → mkdocs2confluence-0.7.25}/src/mkdocs2confluence.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs2confluence
-Version: 0.7.23
+Version: 0.7.25
 Summary: Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more
 Author: Anders Hybertz
 License: GPL-3.0-or-later

{mkdocs2confluence-0.7.23 → mkdocs2confluence-0.7.25}/src/mkdocs_to_confluence/cli.py

@@ -476,12 +476,9 @@ def _cmd_publish(args: argparse.Namespace) -> None:
         with ConfluenceClient(conf_config) as client:
             if conf_config.parent_page_id:
                 # parent_page_id is the authoritative anchor — derive space from it.
-                # space_key is only used when no parent_page_id is configured.
                 space_id = client.get_space_id_from_page(conf_config.parent_page_id)
-                space_key = conf_config.space_key or client.get_space_key_from_page(conf_config.parent_page_id)
             elif conf_config.space_key:
                 space_id = client.get_space_id(conf_config.space_key)
-                space_key = conf_config.space_key
             else:
                 print(
                     "error: cannot determine space — set 'space_key' or 'parent_page_id' in mkdocs.yml",
@@ -494,7 +491,7 @@ def _cmd_publish(args: argparse.Namespace) -> None:
             partial = bool(getattr(args, "page", None) or getattr(args, "section", None))
             report = execute_publish(
                 plan, client, dry_run=False, space_id=space_id,
-                space_key=space_key,
+                space_key=conf_config.space_key,
                 docs_dir=config.docs_dir, full_width=conf_config.full_width,
                 root_page_id=conf_config.parent_page_id,
                 prune=getattr(args, "prune", False) and not partial,

{mkdocs2confluence-0.7.23 → mkdocs2confluence-0.7.25}/src/mkdocs_to_confluence/publisher/client.py

@@ -33,7 +33,7 @@ class ConfluenceClient:
     def __init__(self, config: ConfluenceConfig) -> None:
         self._config = config
         self._client: httpx.Client | None = None
-        self._space_states: dict[str, list[dict[str, Any]]] = {}  # space_key → list of ContentState
+        self._space_states: dict[str, list[dict[str, Any]]] = {}  # cache_key → list of ContentState
 
     # ── Context manager ────────────────────────────────────────────────────────
 
@@ -125,20 +125,6 @@ class ConfluenceClient:
             raise ConfluenceError(f"Could not determine spaceId from page {page_id!r}.")
         return str(space_id)
 
-    def get_space_key_from_page(self, page_id: str) -> str | None:
-        """Return the space key for the space containing *page_id*.
-
-        Uses the v1 content endpoint which includes ``space.key``.
-        Returns ``None`` on any failure (non-fatal — only used for state lookup).
-        """
-        try:
-            url = self._v1(f"/content/{page_id}")
-            resp = self._http.get(url, params={"expand": "space"})
-            if resp.is_success:
-                return resp.json().get("space", {}).get("key") or None
-        except Exception:
-            pass
-        return None
 
     # ── Folders ────────────────────────────────────────────────────────────────
 
@@ -380,28 +366,62 @@ class ConfluenceClient:
     def set_page_status(self, page_id: str, status_key: str, space_key: str | None = None) -> None:
         """Set the Confluence page content state (e.g. ``rough-draft``, ``in-progress``).
 
-        Uses the v1 ``PUT /content/{id}/state`` endpoint.  When *space_key* is
-        provided the space states are fetched once (cached) so the correct
-        ``id``, ``name``, and ``color`` are sent — required to match an
-        existing space state rather than creating a new custom one.
+        Uses ``GET /content/{id}/state/available`` (requires only edit permission) on the
+        first call to discover available space states, then caches them for the run.
+        Sends ``{id, name, color}`` when a matching space state is found, otherwise
+        falls back to ``{name, color}`` with a sensible default colour.
         """
+        def _normalize(s: str) -> str:
+            return s.lower().replace("-", " ").strip()
+
         name = status_key.replace("-", " ").title()
-        state_body: dict[str, Any] = {"name": name}
-
-        if space_key:
-            if space_key not in self._space_states:
-                resp = self._http.get(self._v1(f"/space/{space_key}/state"))
-                if resp.is_success:
-                    self._space_states[space_key] = resp.json() if isinstance(resp.json(), list) else []
-            for state in self._space_states.get(space_key, []):
-                if state.get("name", "").lower() == name.lower():
-                    state_body = {"id": state["id"], "name": state["name"], "color": state["color"]}
-                    break
+        cache_key = space_key or "_default"
+
+        # Fetch space states once per run (keyed by space so one run = one API call)
+        if cache_key not in self._space_states:
+            self._space_states[cache_key] = self._fetch_available_states(page_id)
+
+        matched: dict[str, Any] | None = None
+        for state in self._space_states.get(cache_key, []):
+            if _normalize(state.get("name", "")) == _normalize(name):
+                matched = state
+                break
+
+        if matched:
+            body: dict[str, Any] = {
+                "id": matched["id"],
+                "name": matched["name"],
+                "color": matched["color"],
+            }
+        else:
+            # Fall back: name + color (required together when no id)
+            _default_colors = {
+                "in progress": "#2684ff",
+                "rough draft": "#97a0af",
+                "reviewed": "#57d9a3",
+                "done": "#57d9a3",
+                "in review": "#ffc400",
+                "outdated": "#ff7452",
+            }
+            body = {"name": name, "color": _default_colors.get(_normalize(name), "#2684ff")}
 
         url = self._v1(f"/content/{page_id}/state")
-        resp = self._http.put(url, json=state_body)
+        resp = self._http.put(url, json=body)
         self._raise_for_status(resp, f"set_page_status({page_id!r}, {status_key!r})")
 
+    def _fetch_available_states(self, page_id: str) -> list[dict[str, Any]]:
+        """Fetch space content states via the content-available endpoint.
+
+        Requires only content-edit permission (not space admin).
+        Returns the ``spaceContentStates`` list, which is the same for every
+        page in the space.
+        """
+        resp = self._http.get(self._v1(f"/content/{page_id}/state/available"))
+        if resp.is_success:
+            data: dict[str, Any] = resp.json()
+            return data.get("spaceContentStates") or []
+        return []
+
     def list_attachments(self, page_id: str) -> dict[str, dict[str, Any]]:
         """Return a ``{filename: metadata}`` mapping of all page attachments.
 

{mkdocs2confluence-0.7.23 → mkdocs2confluence-0.7.25}/src/mkdocs_to_confluence/publisher/pipeline.py

@@ -666,8 +666,8 @@ def _post_process_action(
         try:
             client.set_page_status(action.page_id, action.confluence_status, space_key=space_key)
         except Exception as exc:
-            if not quiet:
-                print(f"  [warn] could not set page status '{action.confluence_status}': {exc}", file=sys.stderr)
+            # Always print status errors — user configured status explicitly
+            print(f"  [warn] could not set page status '{action.confluence_status}': {exc}", file=sys.stderr)
 
     # Upload assets — skip files whose mtime is not newer than Confluence.
     if action.page_id and action.attachments:

{mkdocs2confluence-0.7.23 → mkdocs2confluence-0.7.25}/tests/test_publish_client.py

@@ -168,19 +168,60 @@ def test_set_page_labels_skips_post_when_empty() -> None:
 
 
 def test_set_page_status_sends_put() -> None:
-    """set_page_status PUTs name-based body to the v1 /content/{id}/state endpoint."""
-    transport = _MockTransport(httpx.Response(200, json={}))
+    """set_page_status fetches available states then PUTs {name, color} to /content/{id}/state."""
+    # First request: GET /content/42/state/available (returns empty → fallback)
+    # Second request: PUT /content/42/state
+    available_resp = httpx.Response(200, json={"spaceContentStates": [], "customContentStates": []})
+    put_resp = httpx.Response(200, json={})
+    transport = _MockTransport(available_resp, put_resp)
     config = _make_config()
     with ConfluenceClient(config) as client:
         client._client = httpx.Client(transport=transport)  # type: ignore[assignment]
         client.set_page_status("42", "in-progress")
-    assert len(transport.requests) == 1
-    req = transport.requests[0]
+    assert len(transport.requests) == 2
+    assert transport.requests[0].method == "GET"
+    assert "/content/42/state/available" in str(transport.requests[0].url)
+    req = transport.requests[1]
     assert req.method == "PUT"
     assert "/content/42/state" in str(req.url)
     import json
     body = json.loads(req.content)
-    assert body == {"name": "In Progress"}
+    # Fallback: name + default colour (no matching space state)
+    assert body["name"] == "In Progress"
+    assert "color" in body
+
+
+def test_set_page_status_uses_space_state_when_matched() -> None:
+    """set_page_status sends {id, name, color} when a matching space state is found."""
+    space_states = [{"id": 1, "name": "In Progress", "color": "#2684ff"}]
+    available_resp = httpx.Response(200, json={"spaceContentStates": space_states, "customContentStates": []})
+    put_resp = httpx.Response(200, json={})
+    transport = _MockTransport(available_resp, put_resp)
+    config = _make_config()
+    with ConfluenceClient(config) as client:
+        client._client = httpx.Client(transport=transport)  # type: ignore[assignment]
+        client.set_page_status("42", "in-progress")
+    import json
+    body = json.loads(transport.requests[1].content)
+    assert body == {"id": 1, "name": "In Progress", "color": "#2684ff"}
+
+
+def test_set_page_status_caches_space_states() -> None:
+    """Space states are fetched only once even when set_page_status is called twice."""
+    space_states = [{"id": 0, "name": "Rough Draft", "color": "#97a0af"}]
+    available_resp = httpx.Response(200, json={"spaceContentStates": space_states, "customContentStates": []})
+    put_resp = httpx.Response(200, json={})
+    transport = _MockTransport(available_resp, put_resp, put_resp)
+    config = _make_config()
+    with ConfluenceClient(config) as client:
+        client._client = httpx.Client(transport=transport)  # type: ignore[assignment]
+        client.set_page_status("42", "rough-draft")
+        client.set_page_status("99", "rough-draft")
+    # Only one GET (cached), two PUTs
+    gets = [r for r in transport.requests if r.method == "GET"]
+    puts = [r for r in transport.requests if r.method == "PUT"]
+    assert len(gets) == 1
+    assert len(puts) == 2
 
 
 def test_set_page_full_width_creates_property_when_absent() -> None: