python-gitea 0.12.0__tar.gz → 0.12.2__tar.gz

{python_gitea-0.12.0 → python_gitea-0.12.2}/.github/workflows/scheduled_release.yml

@@ -31,7 +31,7 @@ jobs:
 
             - name: Check for new commits
               id: check_commits
-              uses: isaac-cf-wong/detect-git-changes-action@a8b0d224a4fdff017607079f83f01f013b9d66a6 # v0.0.20
+              uses: isaac-cf-wong/detect-git-changes-action@051225b2ef2faf2a02d61f16d1a027cdf941498d # v0.0.21
               with:
                   use-latest-tag: true
 

{python_gitea-0.12.0 → python_gitea-0.12.2}/.github/workflows/support_floor_update.yml

@@ -22,7 +22,7 @@ jobs:
 
             - name: Apply support policy (spec0, from pyproject tool table)
               id: policy
-              uses: isaac-cf-wong/dependency-support-policy-action@dfc24273d70d9730ede96b5fdef09a8d7887cf04 # v0.2.10
+              uses: isaac-cf-wong/dependency-support-policy-action@af9e20cfdcb7d14a4c08614e981e8c2339d3da0f # v0.2.11
               with:
                   mode: update
 

{python_gitea-0.12.0 → python_gitea-0.12.2}/.pre-commit-config.yaml

@@ -16,7 +16,7 @@ repos:
           - id: check-json
 
     - repo: https://github.com/astral-sh/ruff-pre-commit
-      rev: v0.16.9
+      rev: v0.16.10
       hooks:
           - id: ruff
             args: [--fix, --config=pyproject.toml]
@@ -52,7 +52,7 @@ repos:
           - id: actionlint
 
     - repo: https://github.com/astral-sh/uv-pre-commit
-      rev: 0.12.21
+      rev: 0.12.23
       hooks:
           # Update the uv lockfile
           - id: uv-lock

{python_gitea-0.12.0 → python_gitea-0.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-gitea
-Version: 0.12.0
+Version: 0.12.2
 Summary: A Python package for interacting with the Gitea API, offering a simple interface to access repositories, users, organizations, issues, and more for automation and data management.
 Project-URL: Documentation, https://isaac-cf-wong.github.io/python-gitea
 Project-URL: Source, https://github.com/isaac-cf-wong/python-gitea
@@ -18,7 +18,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.12
 Requires-Dist: aiohttp>=3.13.3
-Requires-Dist: platformdirs>=4.3.6
+Requires-Dist: platformdirs>=4.4.0
 Requires-Dist: pydantic>=2.12.5
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: requests>=2.33.0

{python_gitea-0.12.0 → python_gitea-0.12.2}/docs/user-guide/cli.md

@@ -499,8 +499,13 @@ defines. In all of them:
   anything is written, so it works on a Gitea that only accepts IDs. Names are
   matched exactly, case included. A name that matches no label, or more than
   one, fails the command and no issue is changed. A value made only of digits is
-  taken as an ID and sent as it is, which is how a label defined on the
-  organization rather than the repository is named.
+  taken as an ID, which is how a label defined on the organization rather than
+  the repository is named. An ID is checked as well: one that is neither a label
+  of the repository nor of the organization owning it fails the command in the
+  same way, before anything is written. Label IDs belong to the repository or
+  organization that defines them, so an ID read from another repository names a
+  different label, or none; prefer the name, which means the same label wherever
+  it is defined.
 - `--issue-id` can be repeated to act on several issues in one run. With one
   issue, `data` is the list of labels the issue is left with. With several,
   `data` holds one entry per issue, in the order given:

{python_gitea-0.12.0 → python_gitea-0.12.2}/pyproject.toml

@@ -23,22 +23,22 @@ dependencies = [
   "requests>=2.33.0",
   "aiohttp>=3.13.3",
   "pydantic>=2.12.5",
-  "platformdirs>=4.3.6",
+  "platformdirs>=4.4.0",
   "pyyaml>=6.0.2",
 ]
 
 [dependency-groups]
 dev = [
-  "ruff>=0.16.9",
+  "ruff>=0.16.10",
   # The mutation runner, in the environment `uv run` resolves, so that
   # `uv run mutmut run` reaches the same interpreter as `uv run pytest` and finds
   # the pytest plugins the suite's own options need. Run from a tool environment
   # of its own it cannot read `--cov`, and the run dies at collection.
   "mutmut>=3.8.0",
-  "prek>=0.5.3",
+  "prek>=0.5.4",
   "pytest-github-actions-annotate-failures>=0.4.2",
   "pytest-cov>=7.1.0",
-  "pytest-mock>=3.15.1",
+  "pytest-mock>=3.16.0",
   "pytest>=9.1.1",
   "pytest-asyncio>=1.4.0",
 ]

{python_gitea-0.12.0 → python_gitea-0.12.2}/src/gitea/cli/issue/label/common.py

@@ -7,9 +7,13 @@ and one that does not rejects the whole request. Resolving first also means an
 unknown name is an error before anything is written, rather than a label silently
 not applied, and before the first of several issues has been changed.
 
-A value made only of ASCII digits is taken to be an ID and is sent as it is,
-without being looked up. That is what lets a label defined on the organization,
-which the repository's listing does not include, be applied at all.
+A value made only of ASCII digits is taken to be an ID. An ID is checked too,
+against the repository's labels and then, for one not among them, against the
+labels of the organization owning the repository, which the repository's listing
+does not include. An ID found in neither is an error before anything is written:
+Gitea drops an ID it cannot apply without saying so, so an ID copied from another
+repository would otherwise be a silent no-op for `add`, and for `set` would leave
+the issue with no labels at all.
 
 Every command takes one `--issue-id` or several. With one, `data` is that issue's
 labels, as `gitea-cli issue label list` emits them. With several, `data` holds one
@@ -25,6 +29,8 @@ import re
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
+from requests import HTTPError
+
 from gitea.cli.utils.errors import CommandError
 from gitea.utils.pagination import PAGE_SIZE, collect_all_pages
 
@@ -37,6 +43,7 @@ ISSUE_IDS_HELP = "Issue number shown in the web UI. Repeat the option to act on
 LABEL_HELP = "Label name or numeric ID. Repeat the option for several labels."
 
 _NUMERIC_ID = re.compile(r"[0-9]+")
+_NOT_FOUND = 404
 
 
 def require_issue_ids(issue_ids: list[int] | None, *, command: str) -> list[int]:
@@ -79,14 +86,41 @@ def require_labels(labels: list[str] | None, *, command: str, hint: str = "") ->
     return labels
 
 
+def _organization_label_ids(client: Gitea, owner: str) -> set[int]:
+    """Read the IDs of the labels defined on the organization owning a repository.
+
+    Args:
+        client: The client to list the labels with.
+        owner: The owner of the repository.
+
+    Returns:
+        The IDs, or none when the owner is a user rather than an organization,
+        which Gitea answers with a 404.
+
+    Raises:
+        HTTPError: If the listing failed for any other reason.
+
+    """
+    try:
+        defined, _ = collect_all_pages(
+            lambda page: client.label.list_organization_labels(organization=owner, page=page, limit=PAGE_SIZE)
+        )
+    except HTTPError as e:
+        response = getattr(e, "response", None)
+        if response is None or response.status_code != _NOT_FOUND:
+            raise
+        return set()
+    return {label["id"] for label in defined}
+
+
 def resolve_label_ids(client: Gitea, owner: str, repository: str, labels: list[str], *, command: str) -> list[int]:
-    """Resolve the labels given on the command line to their IDs.
+    """Resolve the labels given on the command line to their IDs, and check that each exists.
 
-    The repository's labels are listed only when a name has to be resolved, and
-    then only once for all of them.
+    The repository's labels are listed once for all of them. The organization's
+    are listed only when an ID is not among the repository's.
 
     Args:
-        client: The client to list the repository's labels with.
+        client: The client to list the labels with.
         owner: The owner of the repository.
         repository: The name of the repository.
         labels: The labels, each a name or a numeric ID.
@@ -96,18 +130,19 @@ def resolve_label_ids(client: Gitea, owner: str, repository: str, labels: list[s
         The label IDs, in the order given, each once.
 
     Raises:
-        CommandError: If a name matches no label of the repository, or more than one.
+        CommandError: If a name matches no label of the repository, or more than
+            one, or an ID is neither a label of the repository nor of the
+            organization owning it.
 
     """
-    names = [label for label in labels if not _NUMERIC_ID.fullmatch(label)]
+    defined, _ = collect_all_pages(
+        lambda page: client.label.list_labels(owner=owner, repository=repository, page=page, limit=PAGE_SIZE)
+    )
     by_name: dict[str, list[int]] = {}
-    if names:
-        defined, _ = collect_all_pages(
-            lambda page: client.label.list_labels(owner=owner, repository=repository, page=page, limit=PAGE_SIZE)
-        )
-        for label in defined:
-            by_name.setdefault(label["name"], []).append(label["id"])
+    for label in defined:
+        by_name.setdefault(label["name"], []).append(label["id"])
 
+    names = [label for label in labels if not _NUMERIC_ID.fullmatch(label)]
     unknown = [name for name in names if name not in by_name]
     if unknown:
         raise CommandError(
@@ -122,8 +157,23 @@ def resolve_label_ids(client: Gitea, owner: str, repository: str, labels: list[s
             f"in {owner}/{repository}. Pass the numeric ID of the one you mean."
         )
 
-    ids = [int(label) if _NUMERIC_ID.fullmatch(label) else by_name[label][0] for label in labels]
-    return list(dict.fromkeys(ids))
+    repository_ids = {label["id"] for label in defined}
+    ids = [int(label) for label in labels if _NUMERIC_ID.fullmatch(label)]
+    elsewhere = [label_id for label_id in dict.fromkeys(ids) if label_id not in repository_ids]
+    if elsewhere:
+        organization_ids = _organization_label_ids(client, owner)
+        missing = [label_id for label_id in elsewhere if label_id not in organization_ids]
+        if missing:
+            raise CommandError(
+                f"'{command}': no label with ID {', '.join(str(label_id) for label_id in missing)} "
+                f"in {owner}/{repository} or on its owner {owner}. "
+                f"A label's ID belongs to the repository or organization defining it, so an ID read from "
+                f"another repository names a different label there, or none; nothing was changed. "
+                f"Pass the label's name instead; 'gitea-cli label list' shows the repository's labels."
+            )
+
+    resolved = [int(label) if _NUMERIC_ID.fullmatch(label) else by_name[label][0] for label in labels]
+    return list(dict.fromkeys(resolved))
 
 
 def for_each_issue(

{python_gitea-0.12.0 → python_gitea-0.12.2}/src/gitea/label/async_label.py

@@ -74,6 +74,63 @@ class AsyncLabel(BaseLabel, AsyncResource):
         data, status_code = await process_async_response(response, default=[])
         return cast(list[dict[str, Any]], data), {"status_code": status_code}
 
+    async def _list_organization_labels(
+        self,
+        organization: str,
+        page: int | None = None,
+        limit: int | None = None,
+        **kwargs: Any,
+    ) -> ClientResponse:
+        """List the labels defined on an organization.
+
+        Args:
+            organization: The name of the organization.
+            page: The page number for pagination.
+            limit: The number of labels per page.
+            **kwargs: Additional arguments for the request.
+
+        Returns:
+            The HTTP response object.
+
+        """
+        endpoint, params = self._list_organization_labels_helper(
+            organization=organization,
+            page=page,
+            limit=limit,
+        )
+        return await self._get(endpoint=endpoint, params=params, **kwargs)
+
+    async def list_organization_labels(
+        self,
+        organization: str,
+        page: int | None = None,
+        limit: int | None = None,
+        **kwargs: Any,
+    ) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+        """List the labels defined on an organization.
+
+        These are the labels every repository of the organization can use, and
+        which the listing of a repository's own labels does not include.
+
+        Args:
+            organization: The name of the organization.
+            page: The page number for pagination.
+            limit: The number of labels per page.
+            **kwargs: Additional arguments for the request.
+
+        Returns:
+            A tuple containing a list of labels as dictionaries and a dictionary with metadata.
+
+        """
+        response = await self._list_organization_labels(
+            organization=organization,
+            page=page,
+            limit=limit,
+            **kwargs,
+        )
+        data, status_code = await process_async_response(response, default=[])
+        return cast(list[dict[str, Any]], data), {"status_code": status_code}
+
     async def _create_label(
         self,
         owner: str,

{python_gitea-0.12.0 → python_gitea-0.12.2}/src/gitea/label/base.py

@@ -50,6 +50,45 @@ class BaseLabel:
 
         return endpoint, params
 
+    def _list_organization_labels_endpoint(self, organization: str) -> str:
+        """Construct the endpoint URL for listing the labels defined on an organization.
+
+        Args:
+            organization: The name of the organization.
+
+        Returns:
+            The endpoint URL for listing the organization's labels.
+
+        """
+        return f"/orgs/{organization}/labels"
+
+    def _list_organization_labels_helper(
+        self,
+        organization: str,
+        page: int | None = None,
+        limit: int | None = None,
+    ) -> tuple[str, dict[str, Any]]:
+        """Get the endpoint and parameters for listing the labels defined on an organization.
+
+        Args:
+            organization: The name of the organization.
+            page: The page number for pagination.
+            limit: The number of labels per page.
+
+        Returns:
+            A tuple containing the endpoint and the request arguments.
+
+        """
+        endpoint = self._list_organization_labels_endpoint(organization=organization)
+
+        params = {}
+        if page is not None:
+            params["page"] = page
+        if limit is not None:
+            params["limit"] = limit
+
+        return endpoint, params
+
     def _create_label_endpoint(self, owner: str, repository: str) -> str:
         """Construct the endpoint URL for creating a label in a repository.
 

{python_gitea-0.12.0 → python_gitea-0.12.2}/src/gitea/label/label.py

@@ -74,6 +74,63 @@ class Label(BaseLabel, Resource):
         data, status_code = process_response(response, default=[])
         return cast(list[dict[str, Any]], data), {"status_code": status_code}
 
+    def _list_organization_labels(
+        self,
+        organization: str,
+        page: int | None = None,
+        limit: int | None = None,
+        **kwargs: Any,
+    ) -> Response:
+        """List the labels defined on an organization.
+
+        Args:
+            organization: The name of the organization.
+            page: The page number for pagination.
+            limit: The number of labels per page.
+            **kwargs: Additional arguments for the request.
+
+        Returns:
+            The HTTP response object.
+
+        """
+        endpoint, params = self._list_organization_labels_helper(
+            organization=organization,
+            page=page,
+            limit=limit,
+        )
+        return self._get(endpoint=endpoint, params=params, **kwargs)
+
+    def list_organization_labels(
+        self,
+        organization: str,
+        page: int | None = None,
+        limit: int | None = None,
+        **kwargs: Any,
+    ) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+        """List the labels defined on an organization.
+
+        These are the labels every repository of the organization can use, and
+        which the listing of a repository's own labels does not include.
+
+        Args:
+            organization: The name of the organization.
+            page: The page number for pagination.
+            limit: The number of labels per page.
+            **kwargs: Additional arguments for the request.
+
+        Returns:
+            A tuple containing a list of labels as dictionaries and a dictionary with metadata.
+
+        """
+        response = self._list_organization_labels(
+            organization=organization,
+            page=page,
+            limit=limit,
+            **kwargs,
+        )
+        data, status_code = process_response(response, default=[])
+        return cast(list[dict[str, Any]], data), {"status_code": status_code}
+
     def _create_label(
         self,
         owner: str,

{python_gitea-0.12.0 → python_gitea-0.12.2}/tests/cli/issue/label/test_cli_issue_label.py

@@ -2,7 +2,9 @@
 
 The commands are run against a stand-in for the instance that keeps each issue's
 labels as Gitea does: a POST to an issue's labels appends, a PUT replaces them, a
-DELETE of the list clears it and a DELETE of one label removes that one. A command
+DELETE of the list clears it and a DELETE of one label removes that one. As Gitea
+does, a POST or PUT drops without a word any ID that is not a label of the
+repository or of the organization owning it. A command
 that sent the wrong method would therefore leave the issue with the wrong labels,
 which is what these tests look at, rather than only at which method was sent.
 """
@@ -11,6 +13,7 @@ from __future__ import annotations
 
 import json
 import re
+from http import HTTPStatus
 from pathlib import Path
 from typing import Any
 from unittest.mock import patch
@@ -32,22 +35,33 @@ BUG = {"id": 3, "name": "bug", "color": "ff0000"}
 DOCS = {"id": 5, "name": "docs", "color": "00ff00"}
 URGENT = {"id": 8, "name": "priority: urgent", "color": "0000ff"}
 DEFINED = [BUG, DOCS, URGENT]
+ORG_WIDE = {"id": 900, "name": "org-wide", "color": "cccccc"}
+# An ID no label of the repository or its organization has, as one copied from another repository would be.
+FOREIGN = 266
 
 
 class FailedResponse:
     """The answer of an endpoint refusing a request, as far as the client reads it."""
 
-    status_code = 404
     content = b""
 
+    def __init__(self, status_code: int = 404) -> None:
+        """Answer with the given status.
+
+        Args:
+            status_code: The status of the refusal.
+
+        """
+        self.status_code = status_code
+
     def raise_for_status(self) -> None:
-        """Raise as a refused request does.
+        """Raise as a refused request does, carrying the response as requests does.
 
         Raises:
             requests.HTTPError: Always.
 
         """
-        raise requests.HTTPError("404 Client Error: Not Found")
+        raise requests.HTTPError(f"{self.status_code} Client Error", response=self)
 
     def close(self) -> None:
         """Release the response, as the client does on a failure."""
@@ -61,6 +75,8 @@ class LabelServer(RecordingSession):
         carried: dict[int, list[int]],
         defined: list[dict[str, Any]] | None = None,
         failing: frozenset[int] = frozenset(),
+        organization: list[dict[str, Any]] | None = None,
+        organization_status: int = 200,
     ) -> None:
         """Start the instance with the labels each issue carries.
 
@@ -68,20 +84,27 @@ class LabelServer(RecordingSession):
             carried: The IDs of the labels each issue carries, by issue number.
             defined: The labels the repository defines.
             failing: Issues whose label endpoints refuse every request.
+            organization: The labels the organization owning the repository defines.
+            organization_status: The status the organization's label listing answers
+                with: 404 is what Gitea answers when the owner is a user.
 
         """
         super().__init__()
         self.defined = DEFINED if defined is None else defined
+        self.organization = [] if organization is None else organization
+        self.organization_status = organization_status
         self.carried = {issue: list(ids) for issue, ids in carried.items()}
         self.failing = failing
 
     def _labels_of(self, issue: int) -> list[dict[str, Any]]:
-        by_id = {label["id"]: label for label in self.defined}
+        by_id = {label["id"]: label for label in [*self.defined, *self.organization]}
         return [by_id[label_id] for label_id in self.carried[issue]]
 
     def _ids(self, values: list[int | str]) -> list[int]:
         by_name = {label["name"]: label["id"] for label in self.defined}
-        return [value if isinstance(value, int) else by_name[value] for value in values]
+        applicable = {label["id"] for label in [*self.defined, *self.organization]}
+        ids = [value if isinstance(value, int) else by_name[value] for value in values]
+        return [label_id for label_id in ids if label_id in applicable]
 
     def request(self, method: str, url: str, **kwargs: Any) -> Any:
         """Record a request and answer it as the instance would.
@@ -101,10 +124,17 @@ class LabelServer(RecordingSession):
         self._record(method, url, **kwargs)
         path = url.removeprefix(API_ROOT)
 
-        if path == "/repos/o/r/labels" and method == "GET":
+        listings = {
+            "/repos/o/r/labels": (self.defined, 200),
+            "/orgs/o/labels": (self.organization, self.organization_status),
+        }
+        if path in listings and method == "GET":
+            listed, status = listings[path]
+            if status != HTTPStatus.OK:
+                return FailedResponse(status)
             params = kwargs.get("params") or {}
-            page, limit = params.get("page", 1), params.get("limit", len(self.defined))
-            return RecordedResponse(self.defined[(page - 1) * limit : page * limit])
+            page, limit = params.get("page", 1), params.get("limit", len(listed))
+            return RecordedResponse(listed[(page - 1) * limit : page * limit])
 
         match = re.fullmatch(r"/repos/o/r/issues/(\d+)/labels(?:/(\d+))?", path)
         assert match, f"unexpected request: {method} {url}"
@@ -263,14 +293,90 @@ def test_add_resolves_a_name_on_a_later_page_of_the_listing(config_path):
     assert server.bodies[-1] == {"labels": [159]}
 
 
-def test_a_numeric_label_is_sent_as_an_id_without_listing_the_labels(config_path):
-    """A numeric value is an ID, which needs no lookup and may name an organization label."""
-    server = LabelServer({34: []}, defined=[{"id": 900, "name": "org-wide", "color": "cccccc"}])
+def test_an_id_of_the_repository_is_sent_without_listing_the_organization(config_path):
+    """An ID among the repository's labels needs no further lookup."""
+    server = LabelServer({34: []})
+
+    data_of(run(server, config_path, "add", "--issue-id", "34", "--label", "5"))
+
+    assert [url for _, url in server.requests if "/orgs/" in url] == []
+    assert server.bodies[-1] == {"labels": [5]}
+
+
+def test_an_id_of_an_organization_label_is_applied(config_path):
+    """An ID the repository's listing lacks but its organization defines is a label the issue can carry."""
+    server = LabelServer({34: [3]}, organization=[ORG_WIDE])
+
+    data = data_of(run(server, config_path, "add", "--issue-id", "34", "--label", "900"))
+
+    assert server.bodies[-1] == {"labels": [900]}
+    assert server.carried[34] == [3, 900]
+    assert data == [BUG, ORG_WIDE]
+
+
+@pytest.mark.parametrize("command", ["add", "set", "remove"])
+@pytest.mark.parametrize("organization_status", [200, 404], ids=["organization", "user"])
+def test_an_unknown_id_is_an_error_and_nothing_is_written(config_path, command, organization_status):
+    """An ID of no label here should fail before any issue is changed, whether the owner is an organization or not."""
+    server = LabelServer({34: [3, 5], 35: [8]}, organization=[ORG_WIDE], organization_status=organization_status)
+
+    error = run_failing(server, config_path, command, "--issue-id", "34", "--issue-id", "35", "--label", str(FOREIGN))
+
+    assert f"no label with ID {FOREIGN} in o/r or on its owner o" in error
+    assert "Pass the label's name instead" in error
+    assert server.writes == []
+    assert server.carried == {34: [3, 5], 35: [8]}
+
+
+def test_set_with_known_and_unknown_ids_changes_nothing(config_path):
+    """One unknown ID among known ones should stop `set` before it replaces anything, and be the one named."""
+    server = LabelServer({34: [3, 5]}, organization=[ORG_WIDE])
+
+    error = run_failing(
+        server, config_path, "set", "--issue-id", "34", "--label", "8", "--label", str(FOREIGN), "--label", "900"
+    )
+
+    assert f"no label with ID {FOREIGN} in" in error
+    assert "8," not in error
+    assert "900" not in error
+    assert server.writes == []
+    assert server.carried[34] == [3, 5]
+
 
-    data_of(run(server, config_path, "add", "--issue-id", "34", "--label", "900"))
+def test_every_unknown_id_is_named(config_path):
+    """Several unknown IDs should all be named, each once, so one run shows everything to fix."""
+    server = LabelServer({34: [3]})
 
-    assert server.requests[0] == ("POST", f"{API_ROOT}/repos/o/r/issues/34/labels")
-    assert server.bodies[0] == {"labels": [900]}
+    error = run_failing(
+        server,
+        config_path,
+        "add",
+        "--issue-id",
+        "34",
+        "--label",
+        "266",
+        "--label",
+        "3",
+        "--label",
+        "270",
+        "--label",
+        "266",
+    )
+
+    assert "no label with ID 266, 270 in o/r" in error
+    assert server.writes == []
+
+
+def test_a_failing_organization_listing_fails_the_command_before_writing(config_path):
+    """A refusal other than the 404 of a user owner cannot be read as 'no such label', and should stop the command."""
+    server = LabelServer({34: [3]}, organization_status=500)
+
+    with patch("gitea.cli.utils.api.logger"):
+        result = run(server, config_path, "set", "--issue-id", "34", "--label", "900")
+
+    assert result.exit_code == 1
+    assert server.writes == []
+    assert server.carried[34] == [3]
 
 
 @pytest.mark.parametrize("command", ["add", "set", "remove"])