zop-cli 0.2.1__tar.gz → 0.2.3__tar.gz

{zop_cli-0.2.1 → zop_cli-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zop-cli
-Version: 0.2.1
+Version: 0.2.3
 Summary: High-throughput Zotero CLI focused on batch operations and automation
 Project-URL: Homepage, https://github.com/anomalyco/zop
 Project-URL: Issues, https://github.com/anomalyco/zop/issues

{zop_cli-0.2.1 → zop_cli-0.2.3}/src/zop/_version.py

@@ -2,4 +2,4 @@
 
 from __future__ import annotations
 
-__version__ = "0.2.1"
+__version__ = "0.2.3"

{zop_cli-0.2.1 → zop_cli-0.2.3}/src/zop/adapters/sqlite_reader.py

@@ -412,7 +412,7 @@ class SqliteReader:
         with self._connect() as con:
             rows = con.execute(
                 """
-                SELECT i.key, n.note, i.dateAdded, i.dateModified
+                SELECT i.key, n.note, i.dateAdded, i.dateModified, parent.key
                 FROM itemNotes n
                 JOIN items i ON i.itemID = n.itemID
                 JOIN items parent ON parent.itemID = n.parentItemID
@@ -421,8 +421,20 @@ class SqliteReader:
                 """,
                 (item_key, library_id),
             ).fetchall()
-        return [{"key": r[0], "note": r[1] or "", "date_added": str(r[2]) if r[2] else "",
-                 "date_modified": str(r[3]) if r[3] else ""} for r in rows if r[0]]
+        # parent_key: the parent item's key. The JOIN to `parent` already existed
+        # but the SELECT never read parent.key, so callers couldn't attribute a
+        # note to its item (#2).
+        return [
+            {
+                "key": r[0],
+                "note": r[1] or "",
+                "date_added": str(r[2]) if r[2] else "",
+                "date_modified": str(r[3]) if r[3] else "",
+                "parent_key": r[4],
+            }
+            for r in rows
+            if r[0]
+        ]
 
     def list_all_tags(self, library_id: int = 1) -> list[dict[str, int | str]]:
         with self._connect() as con:

{zop_cli-0.2.1 → zop_cli-0.2.3}/src/zop/adapters/zotero_api.py

@@ -172,6 +172,11 @@ class ZoteroApi:
             parent_key: New parent key. Pass ``None`` or ``False`` to detach to
                 top-level. Default (sentinel) leaves parent unchanged.
             version: If-Unmodified-Since-Version for optimistic locking.
+
+        Returns:
+            The updated collection dict, or an empty dict on an empty response.
+            Zotero answers single-object PATCHes with ``204 No Content``, so
+            callers must not subscript the result to read fields.
         """
         payload: dict[str, Any] = {}
         if name is not None:
@@ -182,7 +187,8 @@ class ZoteroApi:
         if version is not None:
             headers["If-Unmodified-Since-Version"] = str(version)
         resp = await self._client.patch(self._coll_url(key), json=payload, headers=headers)
-        return cast("dict[str, Any]", self._check(resp))
+        result = self._check(resp)
+        return result if isinstance(result, dict) else {}
 
     async def delete_collection(self, key: str, *, version: int | None = None) -> None:
         """Delete a collection. CASCADE: deletes all subcollections."""

{zop_cli-0.2.1 → zop_cli-0.2.3}/src/zop/commands/collection.py

@@ -106,13 +106,13 @@ def delete_cmd(ctx: click.Context, key: str, yes: bool) -> None:
 
 @collection.command("reparent")
 @click.argument("key")
-@click.option("--parent", "parent_name", default=None, help="New parent NAME (omit for top-level).")
+@click.option("--parent", "parent_ref", default=None, help="New parent KEY or NAME (omit for top-level).")
 @click.pass_context
-def reparent_cmd(ctx: click.Context, key: str, parent_name: str | None) -> None:
+def reparent_cmd(ctx: click.Context, key: str, parent_ref: str | None) -> None:
     """Move a collection under a new parent (or to top-level). Requires API key."""
     try:
         svc = _service(ctx)
-        result = asyncio.run(svc.reparent(key, parent_name))
+        result = asyncio.run(svc.reparent(key, parent_ref))
         emit([result.model_dump()], human=_human(), count=1)
     except ZopError as e:
         emit_error(e, human=_human())

{zop_cli-0.2.1 → zop_cli-0.2.3}/src/zop/services/collections.py

@@ -294,23 +294,33 @@ class CollectionsService:
     async def reparent(
         self, key: str, new_parent: str | None, *, version: int | None = None
     ) -> Collection:
-        """Move collection under new parent (NAME), or detach if new_parent is None."""
+        """Move collection under a new parent (KEY or NAME), or detach if None.
 
+        ``new_parent`` may be a collection KEY (8-char) or NAME, resolved the same
+        way as ``create``'s ``--parent`` (KEY first, then local name, then the
+        Web API for a parent not yet in local SQLite). This matches SKILL.md's
+        ``--parent "KeyOrName"`` contract shared by all collection write commands.
+        """
         api = self._require_api()
-        if new_parent is None:
-            parent_key: str | None | object = False  # detach
-        else:
-            parent_key = self.resolve(new_parent).key
         async with api:
+            if new_parent is None:
+                parent_key: str | None | object = False  # detach to top-level
+            else:
+                parent_key = await self._resolve_parent(api, new_parent)
             if version is None:
                 current = await api.get_collection(key)
                 version = current["version"]
-            r = await api.update_collection(key, parent_key=parent_key, version=version)
+            # Zotero PATCH /collections/{key} returns 204 No Content (no body),
+            # so the patch response carries no fields to read. Re-read the
+            # collection to return its true updated state (new version, name,
+            # parent) — subscripting the patch response crashes (BUG-11).
+            await api.update_collection(key, parent_key=parent_key, version=version)
+            updated = await api.get_collection(key)
         return Collection(
-            key=r["key"],
-            name=r["data"]["name"],
-            parent_key=r["data"].get("parentCollection") or None,
-            version=r["version"],
+            key=updated["key"],
+            name=updated["data"]["name"],
+            parent_key=updated["data"].get("parentCollection") or None,
+            version=updated["version"],
         )
 
     async def move_items(

{zop_cli-0.2.1 → zop_cli-0.2.3}/tests/test_collections.py

@@ -222,23 +222,77 @@ async def test_reparent_fetches_version_when_not_provided(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     fake_api.get_collection.return_value = {
-        "key": "K",
+        "key": "KEY00001",
         "version": 5,
         "data": {"name": "n", "parentCollection": False},
     }
-    fake_api.update_collection.return_value = {
+    fake_api.update_collection.return_value = {}  # 204 No Content
+    monkeypatch.setattr(CollectionsService, "_require_api", lambda self: fake_api)
+    svc = CollectionsService(db_path=fake_db, creds=creds)
+
+    await svc.reparent("KEY00001", None)  # detach to top-level
+
+    # get_collection called twice: once to read the version, once to re-read
+    # the updated state (PATCH /collections/{key} returns no body — BUG-11).
+    assert fake_api.get_collection.await_count == 2
+    assert all(c.args == ("KEY00001",) for c in fake_api.get_collection.call_args_list)
+    assert fake_api.update_collection.await_count == 1
+    assert fake_api.update_collection.call_args.kwargs["version"] == 5
+
+
+async def test_reparent_returns_updated_state_after_empty_patch(
+    fake_db: Path,
+    creds: ApiCreds,
+    fake_api: AsyncMock,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """BUG-11: PATCH /collections/{key} returns 204 No Content → update_collection
+    yields {}. reparent must NOT subscript the patch response; it re-reads the
+    collection to build the result, so it returns a Collection instead of
+    raising ``TypeError: 'NoneType' object is not subscriptable``.
+    """
+    fake_api.update_collection.return_value = {}  # real 204 behavior
+    fake_api.get_collection.return_value = {
         "key": "KEY00001",
         "version": 6,
-        "data": {"name": "n", "parentCollection": False},
+        "data": {"name": "ExistingParent", "parentCollection": "PARENT01"},
     }
     monkeypatch.setattr(CollectionsService, "_require_api", lambda self: fake_api)
     svc = CollectionsService(db_path=fake_db, creds=creds)
 
-    await svc.reparent("K", None)  # detach to top-level
+    # "ExistingParent" resolves locally to PARENT01; reparent KEY00001 under it.
+    result = await svc.reparent("KEY00001", "ExistingParent")
 
-    fake_api.get_collection.assert_awaited_once_with("K")
-    assert fake_api.update_collection.await_count == 1
-    assert fake_api.update_collection.call_args.kwargs["version"] == 5
+    assert result.key == "KEY00001"
+    assert result.parent_key == "PARENT01"
+    assert result.version == 6
+
+
+async def test_reparent_accepts_parent_key_directly(
+    fake_db: Path,
+    creds: ApiCreds,
+    fake_api: AsyncMock,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """#1: reparent --parent must accept an 8-char KEY (like create), not just a NAME.
+    Passing a KEY short-circuits name lookup — no list_collections scan. Regression
+    for ``reparent <KEY> --parent <父KEY>`` failing with ``No collection named '<KEY>'``.
+    """
+    fake_api.update_collection.return_value = {}  # 204 No Content
+    fake_api.get_collection.return_value = {
+        "key": "KEY00001",
+        "version": 6,
+        "data": {"name": "child", "parentCollection": "PARENT01"},
+    }
+    monkeypatch.setattr(CollectionsService, "_require_api", lambda self: fake_api)
+    svc = CollectionsService(db_path=fake_db, creds=creds)
+
+    await svc.reparent("KEY00001", "PARENT01")  # an 8-char KEY, not a NAME
+
+    # KEY path must not scan collection names via the API
+    fake_api.list_collections.assert_not_awaited()
+    # update_collection must receive the raw KEY as parent_key
+    assert fake_api.update_collection.call_args.kwargs["parent_key"] == "PARENT01"
 
 
 # ---- create: --parent accepts KEY + API fallback (BUG-7) ----

{zop_cli-0.2.1 → zop_cli-0.2.3}/tests/test_library.py

@@ -45,6 +45,7 @@ def fake_db(tmp_path: Path) -> Iterator[Path]:
         CREATE TABLE fields (fieldID INTEGER PRIMARY KEY, fieldName TEXT);
         CREATE TABLE itemCreators (itemID INT, creatorID INT, orderIndex INT);
         CREATE TABLE creators (creatorID INTEGER PRIMARY KEY, firstName TEXT, lastName TEXT);
+        CREATE TABLE itemNotes (itemID INT, parentItemID INT, note TEXT);
 
         -- Deliberately non-standard itemTypeID mapping (exposes BUG-1).
         INSERT INTO itemTypes VALUES
@@ -73,6 +74,11 @@ def fake_db(tmp_path: Path) -> Iterator[Path]:
         INSERT INTO tags VALUES (1, 'cs.AI'), (2, 'to-read');
         INSERT INTO collections VALUES (1, 1, 'COLL0001');
 
+        -- A child note item (itemID 10) attached to JOURN001 (itemID 1) — for #2.
+        INSERT INTO items (itemID, itemTypeID, dateAdded, dateModified, libraryID, key) VALUES
+            (10, 28, datetime('now','-1 days'), datetime('now'), 1, 'NOTEX001');
+        INSERT INTO itemNotes VALUES (10, 1, 'A note on Paper One');
+
         -- Titles (for duplicates by title + recent display).
         INSERT INTO itemDataValues VALUES (10, 'Paper One');
         INSERT INTO itemData VALUES (1, 1, 10);
@@ -156,3 +162,19 @@ def test_get_item_populates_year(fake_db: Path) -> None:
     reader = SqliteReader(fake_db)
     item = reader.get_item("JOURN001")
     assert item.year == 2024
+
+
+def test_get_item_notes_includes_parent_key(fake_db: Path) -> None:
+    """#2: note list must surface parent_key so callers can attribute a note to
+    its item. The JOIN to the parent item already exists; the SELECT must include
+    parent.key and the returned dict must carry it (not be silently absent).
+    """
+    reader = SqliteReader(fake_db)
+    notes = reader.get_item_notes("JOURN001")
+    assert len(notes) == 1
+    note = notes[0]
+    assert note["key"] == "NOTEX001"
+    assert note["note"] == "A note on Paper One"
+    assert note["parent_key"] == "JOURN001"  # the fix
+    assert note["date_added"]  # non-empty
+    assert note["date_modified"]

{zop_cli-0.2.1 → zop_cli-0.2.3}/tests/test_zotero_api.py

@@ -178,6 +178,24 @@ async def test_get_collection_gets_single_collection(creds: ApiCreds) -> None:
     assert result["version"] == 9
 
 
+# ---- update_collection ----
+
+
+async def test_update_collection_empty_body_returns_empty_dict(creds: ApiCreds) -> None:
+    """BUG-11: Zotero PATCH /collections/{key} returns 204 No Content (empty
+    body). update_collection must yield {} (like update_item), not None — a
+    ``None`` return crashes any caller that subscripts the result (reparent).
+    """
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(204)  # no content
+
+    async with ZoteroApi(creds, transport=httpx.MockTransport(handler)) as api:
+        result = await api.update_collection("K", parent_key="P", version=5)
+
+    assert result == {}
+
+
 # ---- _check status-code mapping ----